You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
463 lines
13 KiB
463 lines
13 KiB
---------------------------------------------------------------- |
|
-- 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;
|
|
|