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

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