----------------------------------------------------------------

-- 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;