464 lines
13 KiB
Ada
464 lines
13 KiB
Ada
----------------------------------------------------------------
|
|
-- ZLib for Ada thick binding. --
|
|
-- --
|
|
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
|
|
-- --
|
|
-- Open source license information is in the zlib.ads file. --
|
|
----------------------------------------------------------------
|
|
|
|
-- $Id: test.adb,v 1.17 2003/08/12 12:13:30 vagul Exp $
|
|
|
|
-- The program has a few aims.
|
|
-- 1. Test ZLib.Ada95 thick binding functionality.
|
|
-- 2. Show the example of use main functionality of the ZLib.Ada95 binding.
|
|
-- 3. Build this program automatically compile all ZLib.Ada95 packages under
|
|
-- GNAT Ada95 compiler.
|
|
|
|
with ZLib.Streams;
|
|
with Ada.Streams.Stream_IO;
|
|
with Ada.Numerics.Discrete_Random;
|
|
|
|
with Ada.Text_IO;
|
|
|
|
with Ada.Calendar;
|
|
|
|
procedure Test is
|
|
|
|
use Ada.Streams;
|
|
use Stream_IO;
|
|
|
|
------------------------------------
|
|
-- Test configuration parameters --
|
|
------------------------------------
|
|
|
|
File_Size : Count := 100_000;
|
|
Continuous : constant Boolean := False;
|
|
|
|
Header : constant ZLib.Header_Type := ZLib.Default;
|
|
-- ZLib.None;
|
|
-- ZLib.Auto;
|
|
-- ZLib.GZip;
|
|
-- Do not use Header other then Default in ZLib versions 1.1.4
|
|
-- and older.
|
|
|
|
Strategy : constant ZLib.Strategy_Type := ZLib.Default_Strategy;
|
|
Init_Random : constant := 10;
|
|
|
|
-- End --
|
|
|
|
In_File_Name : constant String := "testzlib.in";
|
|
-- Name of the input file
|
|
|
|
Z_File_Name : constant String := "testzlib.zlb";
|
|
-- Name of the compressed file.
|
|
|
|
Out_File_Name : constant String := "testzlib.out";
|
|
-- Name of the decompressed file.
|
|
|
|
File_In : File_Type;
|
|
File_Out : File_Type;
|
|
File_Back : File_Type;
|
|
File_Z : ZLib.Streams.Stream_Type;
|
|
|
|
Filter : ZLib.Filter_Type;
|
|
|
|
Time_Stamp : Ada.Calendar.Time;
|
|
|
|
procedure Generate_File;
|
|
-- Generate file of spetsified size with some random data.
|
|
-- The random data is repeatable, for the good compression.
|
|
|
|
procedure Compare_Streams
|
|
(Left, Right : in out Root_Stream_Type'Class);
|
|
-- The procedure compearing data in 2 streams.
|
|
-- It is for compare data before and after compression/decompression.
|
|
|
|
procedure Compare_Files (Left, Right : String);
|
|
-- Compare files. Based on the Compare_Streams.
|
|
|
|
procedure Copy_Streams
|
|
(Source, Target : in out Root_Stream_Type'Class;
|
|
Buffer_Size : in Stream_Element_Offset := 1024);
|
|
-- Copying data from one stream to another. It is for test stream
|
|
-- interface of the library.
|
|
|
|
procedure Data_In
|
|
(Item : out Stream_Element_Array;
|
|
Last : out Stream_Element_Offset);
|
|
-- this procedure is for generic instantiation of
|
|
-- ZLib.Generic_Translate.
|
|
-- reading data from the File_In.
|
|
|
|
procedure Data_Out (Item : in Stream_Element_Array);
|
|
-- this procedure is for generic instantiation of
|
|
-- ZLib.Generic_Translate.
|
|
-- writing data to the File_Out.
|
|
|
|
procedure Stamp;
|
|
-- Store the timestamp to the local variable.
|
|
|
|
procedure Print_Statistic (Msg : String; Data_Size : ZLib.Count);
|
|
-- Print the time statistic with the message.
|
|
|
|
procedure Translate is new ZLib.Generic_Translate
|
|
(Data_In => Data_In,
|
|
Data_Out => Data_Out);
|
|
-- This procedure is moving data from File_In to File_Out
|
|
-- with compression or decompression, depend on initialization of
|
|
-- Filter parameter.
|
|
|
|
-------------------
|
|
-- Compare_Files --
|
|
-------------------
|
|
|
|
procedure Compare_Files (Left, Right : String) is
|
|
Left_File, Right_File : File_Type;
|
|
begin
|
|
Open (Left_File, In_File, Left);
|
|
Open (Right_File, In_File, Right);
|
|
Compare_Streams (Stream (Left_File).all, Stream (Right_File).all);
|
|
Close (Left_File);
|
|
Close (Right_File);
|
|
end Compare_Files;
|
|
|
|
---------------------
|
|
-- Compare_Streams --
|
|
---------------------
|
|
|
|
procedure Compare_Streams
|
|
(Left, Right : in out Ada.Streams.Root_Stream_Type'Class)
|
|
is
|
|
Left_Buffer, Right_Buffer : Stream_Element_Array (0 .. 16#FFF#);
|
|
Left_Last, Right_Last : Stream_Element_Offset;
|
|
begin
|
|
loop
|
|
Read (Left, Left_Buffer, Left_Last);
|
|
Read (Right, Right_Buffer, Right_Last);
|
|
|
|
if Left_Last /= Right_Last then
|
|
Ada.Text_IO.Put_Line ("Compare error :"
|
|
& Stream_Element_Offset'Image (Left_Last)
|
|
& " /= "
|
|
& Stream_Element_Offset'Image (Right_Last));
|
|
|
|
raise Constraint_Error;
|
|
|
|
elsif Left_Buffer (0 .. Left_Last)
|
|
/= Right_Buffer (0 .. Right_Last)
|
|
then
|
|
Ada.Text_IO.Put_Line ("ERROR: IN and OUT files is not equal.");
|
|
raise Constraint_Error;
|
|
|
|
end if;
|
|
|
|
exit when Left_Last < Left_Buffer'Last;
|
|
end loop;
|
|
end Compare_Streams;
|
|
|
|
------------------
|
|
-- Copy_Streams --
|
|
------------------
|
|
|
|
procedure Copy_Streams
|
|
(Source, Target : in out Ada.Streams.Root_Stream_Type'Class;
|
|
Buffer_Size : in Stream_Element_Offset := 1024)
|
|
is
|
|
Buffer : Stream_Element_Array (1 .. Buffer_Size);
|
|
Last : Stream_Element_Offset;
|
|
begin
|
|
loop
|
|
Read (Source, Buffer, Last);
|
|
Write (Target, Buffer (1 .. Last));
|
|
|
|
exit when Last < Buffer'Last;
|
|
end loop;
|
|
end Copy_Streams;
|
|
|
|
-------------
|
|
-- Data_In --
|
|
-------------
|
|
|
|
procedure Data_In
|
|
(Item : out Stream_Element_Array;
|
|
Last : out Stream_Element_Offset) is
|
|
begin
|
|
Read (File_In, Item, Last);
|
|
end Data_In;
|
|
|
|
--------------
|
|
-- Data_Out --
|
|
--------------
|
|
|
|
procedure Data_Out (Item : in Stream_Element_Array) is
|
|
begin
|
|
Write (File_Out, Item);
|
|
end Data_Out;
|
|
|
|
-------------------
|
|
-- Generate_File --
|
|
-------------------
|
|
|
|
procedure Generate_File is
|
|
subtype Visible_Symbols is Stream_Element range 16#20# .. 16#7E#;
|
|
|
|
package Random_Elements is
|
|
new Ada.Numerics.Discrete_Random (Visible_Symbols);
|
|
|
|
Gen : Random_Elements.Generator;
|
|
Buffer : Stream_Element_Array := (1 .. 77 => 16#20#) & 10;
|
|
|
|
Buffer_Count : constant Count := File_Size / Buffer'Length;
|
|
-- Number of same buffers in the packet.
|
|
|
|
Density : constant Count := 30; -- from 0 to Buffer'Length - 2;
|
|
|
|
procedure Fill_Buffer (J, D : in Count);
|
|
-- Change the part of the buffer.
|
|
|
|
-----------------
|
|
-- Fill_Buffer --
|
|
-----------------
|
|
|
|
procedure Fill_Buffer (J, D : in Count) is
|
|
begin
|
|
for K in 0 .. D loop
|
|
Buffer
|
|
(Stream_Element_Offset ((J + K) mod (Buffer'Length - 1) + 1))
|
|
:= Random_Elements.Random (Gen);
|
|
|
|
end loop;
|
|
end Fill_Buffer;
|
|
|
|
begin
|
|
Random_Elements.Reset (Gen, Init_Random);
|
|
|
|
Create (File_In, Out_File, In_File_Name);
|
|
|
|
Fill_Buffer (1, Buffer'Length - 2);
|
|
|
|
for J in 1 .. Buffer_Count loop
|
|
Write (File_In, Buffer);
|
|
|
|
Fill_Buffer (J, Density);
|
|
end loop;
|
|
|
|
-- fill remain size.
|
|
|
|
Write
|
|
(File_In,
|
|
Buffer
|
|
(1 .. Stream_Element_Offset
|
|
(File_Size - Buffer'Length * Buffer_Count)));
|
|
|
|
Flush (File_In);
|
|
Close (File_In);
|
|
end Generate_File;
|
|
|
|
---------------------
|
|
-- Print_Statistic --
|
|
---------------------
|
|
|
|
procedure Print_Statistic (Msg : String; Data_Size : ZLib.Count) is
|
|
use Ada.Calendar;
|
|
use Ada.Text_IO;
|
|
|
|
package Count_IO is new Integer_IO (ZLib.Count);
|
|
|
|
Curr_Dur : Duration := Clock - Time_Stamp;
|
|
begin
|
|
Put (Msg);
|
|
|
|
Set_Col (20);
|
|
Ada.Text_IO.Put ("size =");
|
|
|
|
Count_IO.Put
|
|
(Data_Size,
|
|
Width => Stream_IO.Count'Image (File_Size)'Length);
|
|
|
|
Put_Line (" duration =" & Duration'Image (Curr_Dur));
|
|
end Print_Statistic;
|
|
|
|
-----------
|
|
-- Stamp --
|
|
-----------
|
|
|
|
procedure Stamp is
|
|
begin
|
|
Time_Stamp := Ada.Calendar.Clock;
|
|
end Stamp;
|
|
|
|
begin
|
|
Ada.Text_IO.Put_Line ("ZLib " & ZLib.Version);
|
|
|
|
loop
|
|
Generate_File;
|
|
|
|
for Level in ZLib.Compression_Level'Range loop
|
|
|
|
Ada.Text_IO.Put_Line ("Level ="
|
|
& ZLib.Compression_Level'Image (Level));
|
|
|
|
-- Test generic interface.
|
|
Open (File_In, In_File, In_File_Name);
|
|
Create (File_Out, Out_File, Z_File_Name);
|
|
|
|
Stamp;
|
|
|
|
-- Deflate using generic instantiation.
|
|
|
|
ZLib.Deflate_Init
|
|
(Filter => Filter,
|
|
Level => Level,
|
|
Strategy => Strategy,
|
|
Header => Header);
|
|
|
|
Translate (Filter);
|
|
Print_Statistic ("Generic compress", ZLib.Total_Out (Filter));
|
|
ZLib.Close (Filter);
|
|
|
|
Close (File_In);
|
|
Close (File_Out);
|
|
|
|
Open (File_In, In_File, Z_File_Name);
|
|
Create (File_Out, Out_File, Out_File_Name);
|
|
|
|
Stamp;
|
|
|
|
-- Inflate using generic instantiation.
|
|
|
|
ZLib.Inflate_Init (Filter, Header => Header);
|
|
|
|
Translate (Filter);
|
|
Print_Statistic ("Generic decompress", ZLib.Total_Out (Filter));
|
|
|
|
ZLib.Close (Filter);
|
|
|
|
Close (File_In);
|
|
Close (File_Out);
|
|
|
|
Compare_Files (In_File_Name, Out_File_Name);
|
|
|
|
-- Test stream interface.
|
|
|
|
-- Compress to the back stream.
|
|
|
|
Open (File_In, In_File, In_File_Name);
|
|
Create (File_Back, Out_File, Z_File_Name);
|
|
|
|
Stamp;
|
|
|
|
ZLib.Streams.Create
|
|
(Stream => File_Z,
|
|
Mode => ZLib.Streams.Out_Stream,
|
|
Back => ZLib.Streams.Stream_Access
|
|
(Stream (File_Back)),
|
|
Back_Compressed => True,
|
|
Level => Level,
|
|
Strategy => Strategy,
|
|
Header => Header);
|
|
|
|
Copy_Streams
|
|
(Source => Stream (File_In).all,
|
|
Target => File_Z);
|
|
|
|
-- Flushing internal buffers to the back stream.
|
|
|
|
ZLib.Streams.Flush (File_Z, ZLib.Finish);
|
|
|
|
Print_Statistic ("Write compress",
|
|
ZLib.Streams.Write_Total_Out (File_Z));
|
|
|
|
ZLib.Streams.Close (File_Z);
|
|
|
|
Close (File_In);
|
|
Close (File_Back);
|
|
|
|
-- Compare reading from original file and from
|
|
-- decompression stream.
|
|
|
|
Open (File_In, In_File, In_File_Name);
|
|
Open (File_Back, In_File, Z_File_Name);
|
|
|
|
ZLib.Streams.Create
|
|
(Stream => File_Z,
|
|
Mode => ZLib.Streams.In_Stream,
|
|
Back => ZLib.Streams.Stream_Access
|
|
(Stream (File_Back)),
|
|
Back_Compressed => True,
|
|
Header => Header);
|
|
|
|
Stamp;
|
|
Compare_Streams (Stream (File_In).all, File_Z);
|
|
|
|
Print_Statistic ("Read decompress",
|
|
ZLib.Streams.Read_Total_Out (File_Z));
|
|
|
|
ZLib.Streams.Close (File_Z);
|
|
Close (File_In);
|
|
Close (File_Back);
|
|
|
|
-- Compress by reading from compression stream.
|
|
|
|
Open (File_Back, In_File, In_File_Name);
|
|
Create (File_Out, Out_File, Z_File_Name);
|
|
|
|
ZLib.Streams.Create
|
|
(Stream => File_Z,
|
|
Mode => ZLib.Streams.In_Stream,
|
|
Back => ZLib.Streams.Stream_Access
|
|
(Stream (File_Back)),
|
|
Back_Compressed => False,
|
|
Level => Level,
|
|
Strategy => Strategy,
|
|
Header => Header);
|
|
|
|
Stamp;
|
|
Copy_Streams
|
|
(Source => File_Z,
|
|
Target => Stream (File_Out).all);
|
|
|
|
Print_Statistic ("Read compress",
|
|
ZLib.Streams.Read_Total_Out (File_Z));
|
|
|
|
ZLib.Streams.Close (File_Z);
|
|
|
|
Close (File_Out);
|
|
Close (File_Back);
|
|
|
|
-- Decompress to decompression stream.
|
|
|
|
Open (File_In, In_File, Z_File_Name);
|
|
Create (File_Back, Out_File, Out_File_Name);
|
|
|
|
ZLib.Streams.Create
|
|
(Stream => File_Z,
|
|
Mode => ZLib.Streams.Out_Stream,
|
|
Back => ZLib.Streams.Stream_Access
|
|
(Stream (File_Back)),
|
|
Back_Compressed => False,
|
|
Header => Header);
|
|
|
|
Stamp;
|
|
|
|
Copy_Streams
|
|
(Source => Stream (File_In).all,
|
|
Target => File_Z);
|
|
|
|
Print_Statistic ("Write decompress",
|
|
ZLib.Streams.Write_Total_Out (File_Z));
|
|
|
|
ZLib.Streams.Close (File_Z);
|
|
Close (File_In);
|
|
Close (File_Back);
|
|
|
|
Compare_Files (In_File_Name, Out_File_Name);
|
|
end loop;
|
|
|
|
Ada.Text_IO.Put_Line (Count'Image (File_Size) & " Ok.");
|
|
|
|
exit when not Continuous;
|
|
|
|
File_Size := File_Size + 1;
|
|
end loop;
|
|
end Test;
|