Edit

kc3-lang/zlib/contrib/ada/test.adb

Branch :

  • Browse

    Commit

  • Author : Mark Adler
    Date : 2011-09-09 23:22:37
    Hash : 4b5a43a2
    Message : zlib 1.2.0.5

  • contrib/ada/test.adb
  • ----------------------------------------------------------------
    --  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;