diff options
Diffstat (limited to 'contrib/ada/test.adb')
-rw-r--r-- | contrib/ada/test.adb | 463 |
1 files changed, 463 insertions, 0 deletions
diff --git a/contrib/ada/test.adb b/contrib/ada/test.adb new file mode 100644 index 0000000..90773ac --- /dev/null +++ b/contrib/ada/test.adb | |||
@@ -0,0 +1,463 @@ | |||
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; | ||