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