| 1 |
---------------------------------------------------------------- |
| 2 |
-- ZLib for Ada thick binding. -- |
| 3 |
-- -- |
| 4 |
-- Copyright (C) 2002-2003 Dmitriy Anisimkov -- |
| 5 |
-- -- |
| 6 |
-- Open source license information is in the zlib.ads file. -- |
| 7 |
---------------------------------------------------------------- |
| 8 |
|
| 9 |
-- $Id: test.adb,v 1.17 2003/08/12 12:13:30 vagul Exp $ |
| 10 |
|
| 11 |
-- The program has a few aims. |
| 12 |
-- 1. Test ZLib.Ada95 thick binding functionality. |
| 13 |
-- 2. Show the example of use main functionality of the ZLib.Ada95 binding. |
| 14 |
-- 3. Build this program automatically compile all ZLib.Ada95 packages under |
| 15 |
-- GNAT Ada95 compiler. |
| 16 |
|
| 17 |
with ZLib.Streams; |
| 18 |
with Ada.Streams.Stream_IO; |
| 19 |
with Ada.Numerics.Discrete_Random; |
| 20 |
|
| 21 |
with Ada.Text_IO; |
| 22 |
|
| 23 |
with Ada.Calendar; |
| 24 |
|
| 25 |
procedure Test is |
| 26 |
|
| 27 |
use Ada.Streams; |
| 28 |
use Stream_IO; |
| 29 |
|
| 30 |
------------------------------------ |
| 31 |
-- Test configuration parameters -- |
| 32 |
------------------------------------ |
| 33 |
|
| 34 |
File_Size : Count := 100_000; |
| 35 |
Continuous : constant Boolean := False; |
| 36 |
|
| 37 |
Header : constant ZLib.Header_Type := ZLib.Default; |
| 38 |
-- ZLib.None; |
| 39 |
-- ZLib.Auto; |
| 40 |
-- ZLib.GZip; |
| 41 |
-- Do not use Header other then Default in ZLib versions 1.1.4 |
| 42 |
-- and older. |
| 43 |
|
| 44 |
Strategy : constant ZLib.Strategy_Type := ZLib.Default_Strategy; |
| 45 |
Init_Random : constant := 10; |
| 46 |
|
| 47 |
-- End -- |
| 48 |
|
| 49 |
In_File_Name : constant String := "testzlib.in"; |
| 50 |
-- Name of the input file |
| 51 |
|
| 52 |
Z_File_Name : constant String := "testzlib.zlb"; |
| 53 |
-- Name of the compressed file. |
| 54 |
|
| 55 |
Out_File_Name : constant String := "testzlib.out"; |
| 56 |
-- Name of the decompressed file. |
| 57 |
|
| 58 |
File_In : File_Type; |
| 59 |
File_Out : File_Type; |
| 60 |
File_Back : File_Type; |
| 61 |
File_Z : ZLib.Streams.Stream_Type; |
| 62 |
|
| 63 |
Filter : ZLib.Filter_Type; |
| 64 |
|
| 65 |
Time_Stamp : Ada.Calendar.Time; |
| 66 |
|
| 67 |
procedure Generate_File; |
| 68 |
-- Generate file of spetsified size with some random data. |
| 69 |
-- The random data is repeatable, for the good compression. |
| 70 |
|
| 71 |
procedure Compare_Streams |
| 72 |
(Left, Right : in out Root_Stream_Type'Class); |
| 73 |
-- The procedure compearing data in 2 streams. |
| 74 |
-- It is for compare data before and after compression/decompression. |
| 75 |
|
| 76 |
procedure Compare_Files (Left, Right : String); |
| 77 |
-- Compare files. Based on the Compare_Streams. |
| 78 |
|
| 79 |
procedure Copy_Streams |
| 80 |
(Source, Target : in out Root_Stream_Type'Class; |
| 81 |
Buffer_Size : in Stream_Element_Offset := 1024); |
| 82 |
-- Copying data from one stream to another. It is for test stream |
| 83 |
-- interface of the library. |
| 84 |
|
| 85 |
procedure Data_In |
| 86 |
(Item : out Stream_Element_Array; |
| 87 |
Last : out Stream_Element_Offset); |
| 88 |
-- this procedure is for generic instantiation of |
| 89 |
-- ZLib.Generic_Translate. |
| 90 |
-- reading data from the File_In. |
| 91 |
|
| 92 |
procedure Data_Out (Item : in Stream_Element_Array); |
| 93 |
-- this procedure is for generic instantiation of |
| 94 |
-- ZLib.Generic_Translate. |
| 95 |
-- writing data to the File_Out. |
| 96 |
|
| 97 |
procedure Stamp; |
| 98 |
-- Store the timestamp to the local variable. |
| 99 |
|
| 100 |
procedure Print_Statistic (Msg : String; Data_Size : ZLib.Count); |
| 101 |
-- Print the time statistic with the message. |
| 102 |
|
| 103 |
procedure Translate is new ZLib.Generic_Translate |
| 104 |
(Data_In => Data_In, |
| 105 |
Data_Out => Data_Out); |
| 106 |
-- This procedure is moving data from File_In to File_Out |
| 107 |
-- with compression or decompression, depend on initialization of |
| 108 |
-- Filter parameter. |
| 109 |
|
| 110 |
------------------- |
| 111 |
-- Compare_Files -- |
| 112 |
------------------- |
| 113 |
|
| 114 |
procedure Compare_Files (Left, Right : String) is |
| 115 |
Left_File, Right_File : File_Type; |
| 116 |
begin |
| 117 |
Open (Left_File, In_File, Left); |
| 118 |
Open (Right_File, In_File, Right); |
| 119 |
Compare_Streams (Stream (Left_File).all, Stream (Right_File).all); |
| 120 |
Close (Left_File); |
| 121 |
Close (Right_File); |
| 122 |
end Compare_Files; |
| 123 |
|
| 124 |
--------------------- |
| 125 |
-- Compare_Streams -- |
| 126 |
--------------------- |
| 127 |
|
| 128 |
procedure Compare_Streams |
| 129 |
(Left, Right : in out Ada.Streams.Root_Stream_Type'Class) |
| 130 |
is |
| 131 |
Left_Buffer, Right_Buffer : Stream_Element_Array (0 .. 16#FFF#); |
| 132 |
Left_Last, Right_Last : Stream_Element_Offset; |
| 133 |
begin |
| 134 |
loop |
| 135 |
Read (Left, Left_Buffer, Left_Last); |
| 136 |
Read (Right, Right_Buffer, Right_Last); |
| 137 |
|
| 138 |
if Left_Last /= Right_Last then |
| 139 |
Ada.Text_IO.Put_Line ("Compare error :" |
| 140 |
& Stream_Element_Offset'Image (Left_Last) |
| 141 |
& " /= " |
| 142 |
& Stream_Element_Offset'Image (Right_Last)); |
| 143 |
|
| 144 |
raise Constraint_Error; |
| 145 |
|
| 146 |
elsif Left_Buffer (0 .. Left_Last) |
| 147 |
/= Right_Buffer (0 .. Right_Last) |
| 148 |
then |
| 149 |
Ada.Text_IO.Put_Line ("ERROR: IN and OUT files is not equal."); |
| 150 |
raise Constraint_Error; |
| 151 |
|
| 152 |
end if; |
| 153 |
|
| 154 |
exit when Left_Last < Left_Buffer'Last; |
| 155 |
end loop; |
| 156 |
end Compare_Streams; |
| 157 |
|
| 158 |
------------------ |
| 159 |
-- Copy_Streams -- |
| 160 |
------------------ |
| 161 |
|
| 162 |
procedure Copy_Streams |
| 163 |
(Source, Target : in out Ada.Streams.Root_Stream_Type'Class; |
| 164 |
Buffer_Size : in Stream_Element_Offset := 1024) |
| 165 |
is |
| 166 |
Buffer : Stream_Element_Array (1 .. Buffer_Size); |
| 167 |
Last : Stream_Element_Offset; |
| 168 |
begin |
| 169 |
loop |
| 170 |
Read (Source, Buffer, Last); |
| 171 |
Write (Target, Buffer (1 .. Last)); |
| 172 |
|
| 173 |
exit when Last < Buffer'Last; |
| 174 |
end loop; |
| 175 |
end Copy_Streams; |
| 176 |
|
| 177 |
------------- |
| 178 |
-- Data_In -- |
| 179 |
------------- |
| 180 |
|
| 181 |
procedure Data_In |
| 182 |
(Item : out Stream_Element_Array; |
| 183 |
Last : out Stream_Element_Offset) is |
| 184 |
begin |
| 185 |
Read (File_In, Item, Last); |
| 186 |
end Data_In; |
| 187 |
|
| 188 |
-------------- |
| 189 |
-- Data_Out -- |
| 190 |
-------------- |
| 191 |
|
| 192 |
procedure Data_Out (Item : in Stream_Element_Array) is |
| 193 |
begin |
| 194 |
Write (File_Out, Item); |
| 195 |
end Data_Out; |
| 196 |
|
| 197 |
------------------- |
| 198 |
-- Generate_File -- |
| 199 |
------------------- |
| 200 |
|
| 201 |
procedure Generate_File is |
| 202 |
subtype Visible_Symbols is Stream_Element range 16#20# .. 16#7E#; |
| 203 |
|
| 204 |
package Random_Elements is |
| 205 |
new Ada.Numerics.Discrete_Random (Visible_Symbols); |
| 206 |
|
| 207 |
Gen : Random_Elements.Generator; |
| 208 |
Buffer : Stream_Element_Array := (1 .. 77 => 16#20#) & 10; |
| 209 |
|
| 210 |
Buffer_Count : constant Count := File_Size / Buffer'Length; |
| 211 |
-- Number of same buffers in the packet. |
| 212 |
|
| 213 |
Density : constant Count := 30; -- from 0 to Buffer'Length - 2; |
| 214 |
|
| 215 |
procedure Fill_Buffer (J, D : in Count); |
| 216 |
-- Change the part of the buffer. |
| 217 |
|
| 218 |
----------------- |
| 219 |
-- Fill_Buffer -- |
| 220 |
----------------- |
| 221 |
|
| 222 |
procedure Fill_Buffer (J, D : in Count) is |
| 223 |
begin |
| 224 |
for K in 0 .. D loop |
| 225 |
Buffer |
| 226 |
(Stream_Element_Offset ((J + K) mod (Buffer'Length - 1) + 1)) |
| 227 |
:= Random_Elements.Random (Gen); |
| 228 |
|
| 229 |
end loop; |
| 230 |
end Fill_Buffer; |
| 231 |
|
| 232 |
begin |
| 233 |
Random_Elements.Reset (Gen, Init_Random); |
| 234 |
|
| 235 |
Create (File_In, Out_File, In_File_Name); |
| 236 |
|
| 237 |
Fill_Buffer (1, Buffer'Length - 2); |
| 238 |
|
| 239 |
for J in 1 .. Buffer_Count loop |
| 240 |
Write (File_In, Buffer); |
| 241 |
|
| 242 |
Fill_Buffer (J, Density); |
| 243 |
end loop; |
| 244 |
|
| 245 |
-- fill remain size. |
| 246 |
|
| 247 |
Write |
| 248 |
(File_In, |
| 249 |
Buffer |
| 250 |
(1 .. Stream_Element_Offset |
| 251 |
(File_Size - Buffer'Length * Buffer_Count))); |
| 252 |
|
| 253 |
Flush (File_In); |
| 254 |
Close (File_In); |
| 255 |
end Generate_File; |
| 256 |
|
| 257 |
--------------------- |
| 258 |
-- Print_Statistic -- |
| 259 |
--------------------- |
| 260 |
|
| 261 |
procedure Print_Statistic (Msg : String; Data_Size : ZLib.Count) is |
| 262 |
use Ada.Calendar; |
| 263 |
use Ada.Text_IO; |
| 264 |
|
| 265 |
package Count_IO is new Integer_IO (ZLib.Count); |
| 266 |
|
| 267 |
Curr_Dur : Duration := Clock - Time_Stamp; |
| 268 |
begin |
| 269 |
Put (Msg); |
| 270 |
|
| 271 |
Set_Col (20); |
| 272 |
Ada.Text_IO.Put ("size ="); |
| 273 |
|
| 274 |
Count_IO.Put |
| 275 |
(Data_Size, |
| 276 |
Width => Stream_IO.Count'Image (File_Size)'Length); |
| 277 |
|
| 278 |
Put_Line (" duration =" & Duration'Image (Curr_Dur)); |
| 279 |
end Print_Statistic; |
| 280 |
|
| 281 |
----------- |
| 282 |
-- Stamp -- |
| 283 |
----------- |
| 284 |
|
| 285 |
procedure Stamp is |
| 286 |
begin |
| 287 |
Time_Stamp := Ada.Calendar.Clock; |
| 288 |
end Stamp; |
| 289 |
|
| 290 |
begin |
| 291 |
Ada.Text_IO.Put_Line ("ZLib " & ZLib.Version); |
| 292 |
|
| 293 |
loop |
| 294 |
Generate_File; |
| 295 |
|
| 296 |
for Level in ZLib.Compression_Level'Range loop |
| 297 |
|
| 298 |
Ada.Text_IO.Put_Line ("Level =" |
| 299 |
& ZLib.Compression_Level'Image (Level)); |
| 300 |
|
| 301 |
-- Test generic interface. |
| 302 |
Open (File_In, In_File, In_File_Name); |
| 303 |
Create (File_Out, Out_File, Z_File_Name); |
| 304 |
|
| 305 |
Stamp; |
| 306 |
|
| 307 |
-- Deflate using generic instantiation. |
| 308 |
|
| 309 |
ZLib.Deflate_Init |
| 310 |
(Filter => Filter, |
| 311 |
Level => Level, |
| 312 |
Strategy => Strategy, |
| 313 |
Header => Header); |
| 314 |
|
| 315 |
Translate (Filter); |
| 316 |
Print_Statistic ("Generic compress", ZLib.Total_Out (Filter)); |
| 317 |
ZLib.Close (Filter); |
| 318 |
|
| 319 |
Close (File_In); |
| 320 |
Close (File_Out); |
| 321 |
|
| 322 |
Open (File_In, In_File, Z_File_Name); |
| 323 |
Create (File_Out, Out_File, Out_File_Name); |
| 324 |
|
| 325 |
Stamp; |
| 326 |
|
| 327 |
-- Inflate using generic instantiation. |
| 328 |
|
| 329 |
ZLib.Inflate_Init (Filter, Header => Header); |
| 330 |
|
| 331 |
Translate (Filter); |
| 332 |
Print_Statistic ("Generic decompress", ZLib.Total_Out (Filter)); |
| 333 |
|
| 334 |
ZLib.Close (Filter); |
| 335 |
|
| 336 |
Close (File_In); |
| 337 |
Close (File_Out); |
| 338 |
|
| 339 |
Compare_Files (In_File_Name, Out_File_Name); |
| 340 |
|
| 341 |
-- Test stream interface. |
| 342 |
|
| 343 |
-- Compress to the back stream. |
| 344 |
|
| 345 |
Open (File_In, In_File, In_File_Name); |
| 346 |
Create (File_Back, Out_File, Z_File_Name); |
| 347 |
|
| 348 |
Stamp; |
| 349 |
|
| 350 |
ZLib.Streams.Create |
| 351 |
(Stream => File_Z, |
| 352 |
Mode => ZLib.Streams.Out_Stream, |
| 353 |
Back => ZLib.Streams.Stream_Access |
| 354 |
(Stream (File_Back)), |
| 355 |
Back_Compressed => True, |
| 356 |
Level => Level, |
| 357 |
Strategy => Strategy, |
| 358 |
Header => Header); |
| 359 |
|
| 360 |
Copy_Streams |
| 361 |
(Source => Stream (File_In).all, |
| 362 |
Target => File_Z); |
| 363 |
|
| 364 |
-- Flushing internal buffers to the back stream. |
| 365 |
|
| 366 |
ZLib.Streams.Flush (File_Z, ZLib.Finish); |
| 367 |
|
| 368 |
Print_Statistic ("Write compress", |
| 369 |
ZLib.Streams.Write_Total_Out (File_Z)); |
| 370 |
|
| 371 |
ZLib.Streams.Close (File_Z); |
| 372 |
|
| 373 |
Close (File_In); |
| 374 |
Close (File_Back); |
| 375 |
|
| 376 |
-- Compare reading from original file and from |
| 377 |
-- decompression stream. |
| 378 |
|
| 379 |
Open (File_In, In_File, In_File_Name); |
| 380 |
Open (File_Back, In_File, Z_File_Name); |
| 381 |
|
| 382 |
ZLib.Streams.Create |
| 383 |
(Stream => File_Z, |
| 384 |
Mode => ZLib.Streams.In_Stream, |
| 385 |
Back => ZLib.Streams.Stream_Access |
| 386 |
(Stream (File_Back)), |
| 387 |
Back_Compressed => True, |
| 388 |
Header => Header); |
| 389 |
|
| 390 |
Stamp; |
| 391 |
Compare_Streams (Stream (File_In).all, File_Z); |
| 392 |
|
| 393 |
Print_Statistic ("Read decompress", |
| 394 |
ZLib.Streams.Read_Total_Out (File_Z)); |
| 395 |
|
| 396 |
ZLib.Streams.Close (File_Z); |
| 397 |
Close (File_In); |
| 398 |
Close (File_Back); |
| 399 |
|
| 400 |
-- Compress by reading from compression stream. |
| 401 |
|
| 402 |
Open (File_Back, In_File, In_File_Name); |
| 403 |
Create (File_Out, Out_File, Z_File_Name); |
| 404 |
|
| 405 |
ZLib.Streams.Create |
| 406 |
(Stream => File_Z, |
| 407 |
Mode => ZLib.Streams.In_Stream, |
| 408 |
Back => ZLib.Streams.Stream_Access |
| 409 |
(Stream (File_Back)), |
| 410 |
Back_Compressed => False, |
| 411 |
Level => Level, |
| 412 |
Strategy => Strategy, |
| 413 |
Header => Header); |
| 414 |
|
| 415 |
Stamp; |
| 416 |
Copy_Streams |
| 417 |
(Source => File_Z, |
| 418 |
Target => Stream (File_Out).all); |
| 419 |
|
| 420 |
Print_Statistic ("Read compress", |
| 421 |
ZLib.Streams.Read_Total_Out (File_Z)); |
| 422 |
|
| 423 |
ZLib.Streams.Close (File_Z); |
| 424 |
|
| 425 |
Close (File_Out); |
| 426 |
Close (File_Back); |
| 427 |
|
| 428 |
-- Decompress to decompression stream. |
| 429 |
|
| 430 |
Open (File_In, In_File, Z_File_Name); |
| 431 |
Create (File_Back, Out_File, Out_File_Name); |
| 432 |
|
| 433 |
ZLib.Streams.Create |
| 434 |
(Stream => File_Z, |
| 435 |
Mode => ZLib.Streams.Out_Stream, |
| 436 |
Back => ZLib.Streams.Stream_Access |
| 437 |
(Stream (File_Back)), |
| 438 |
Back_Compressed => False, |
| 439 |
Header => Header); |
| 440 |
|
| 441 |
Stamp; |
| 442 |
|
| 443 |
Copy_Streams |
| 444 |
(Source => Stream (File_In).all, |
| 445 |
Target => File_Z); |
| 446 |
|
| 447 |
Print_Statistic ("Write decompress", |
| 448 |
ZLib.Streams.Write_Total_Out (File_Z)); |
| 449 |
|
| 450 |
ZLib.Streams.Close (File_Z); |
| 451 |
Close (File_In); |
| 452 |
Close (File_Back); |
| 453 |
|
| 454 |
Compare_Files (In_File_Name, Out_File_Name); |
| 455 |
end loop; |
| 456 |
|
| 457 |
Ada.Text_IO.Put_Line (Count'Image (File_Size) & " Ok."); |
| 458 |
|
| 459 |
exit when not Continuous; |
| 460 |
|
| 461 |
File_Size := File_Size + 1; |
| 462 |
end loop; |
| 463 |
end Test; |
