← Back to branch summary

~ubuntu-branches/ubuntu/utopic/critcl/utopic

« back to all changes in this revision

Viewing changes to examples/zlibwrap/zlib/contrib/ada/test.adb

  • Committer: Package Import Robot
  • Author(s): Andrew Shadura
  • Date: 2013-05-11 00:08:06 UTC
  • Revision ID: package-import@ubuntu.com-20130511000806-7hq1zc3fnn0gat79
Tags: upstream-3.1.9
Import upstream version 3.1.9

Show diffs side-by-side

added added

removed removed

Lines of Context:
examples/zlibwrap/zlib/contrib/ada/test.adb
 
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 66 2005-08-17 18:20:58Z andreas_kupries $
 
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;