1 | /* example.c -- usage example of the zlib compression library |
---|
2 | * Copyright (C) 1995-2006 Jean-loup Gailly. |
---|
3 | * For conditions of distribution and use, see copyright notice in zlib.h |
---|
4 | */ |
---|
5 | |
---|
6 | /* @(#) $Id$ */ |
---|
7 | |
---|
8 | #include "zlib.h" |
---|
9 | #include <stdio.h> |
---|
10 | |
---|
11 | #ifdef STDC |
---|
12 | # include <string.h> |
---|
13 | # include <stdlib.h> |
---|
14 | #endif |
---|
15 | |
---|
16 | #if defined(VMS) || defined(RISCOS) |
---|
17 | # define TESTFILE "foo-gz" |
---|
18 | #else |
---|
19 | # define TESTFILE "foo.gz" |
---|
20 | #endif |
---|
21 | |
---|
22 | #define CHECK_ERR(err, msg) { \ |
---|
23 | if (err != Z_OK) { \ |
---|
24 | fprintf(stderr, "%s error: %d\n", msg, err); \ |
---|
25 | exit(1); \ |
---|
26 | } \ |
---|
27 | } |
---|
28 | |
---|
29 | const char hello[] = "hello, hello!"; |
---|
30 | /* "hello world" would be more standard, but the repeated "hello" |
---|
31 | * stresses the compression code better, sorry... |
---|
32 | */ |
---|
33 | |
---|
34 | const char dictionary[] = "hello"; |
---|
35 | uLong dictId; /* Adler32 value of the dictionary */ |
---|
36 | |
---|
37 | void test_compress OF((Byte *compr, uLong comprLen, |
---|
38 | Byte *uncompr, uLong uncomprLen)); |
---|
39 | void test_gzio OF((const char *fname, |
---|
40 | Byte *uncompr, uLong uncomprLen)); |
---|
41 | void test_deflate OF((Byte *compr, uLong comprLen)); |
---|
42 | void test_inflate OF((Byte *compr, uLong comprLen, |
---|
43 | Byte *uncompr, uLong uncomprLen)); |
---|
44 | void test_large_deflate OF((Byte *compr, uLong comprLen, |
---|
45 | Byte *uncompr, uLong uncomprLen)); |
---|
46 | void test_large_inflate OF((Byte *compr, uLong comprLen, |
---|
47 | Byte *uncompr, uLong uncomprLen)); |
---|
48 | void test_flush OF((Byte *compr, uLong *comprLen)); |
---|
49 | void test_sync OF((Byte *compr, uLong comprLen, |
---|
50 | Byte *uncompr, uLong uncomprLen)); |
---|
51 | void test_dict_deflate OF((Byte *compr, uLong comprLen)); |
---|
52 | void test_dict_inflate OF((Byte *compr, uLong comprLen, |
---|
53 | Byte *uncompr, uLong uncomprLen)); |
---|
54 | int main OF((int argc, char *argv[])); |
---|
55 | |
---|
56 | /* =========================================================================== |
---|
57 | * Test compress() and uncompress() |
---|
58 | */ |
---|
59 | void test_compress(compr, comprLen, uncompr, uncomprLen) |
---|
60 | Byte *compr, *uncompr; |
---|
61 | uLong comprLen, uncomprLen; |
---|
62 | { |
---|
63 | int err; |
---|
64 | uLong len = (uLong)strlen(hello)+1; |
---|
65 | |
---|
66 | err = compress(compr, &comprLen, (const Bytef*)hello, len); |
---|
67 | CHECK_ERR(err, "compress"); |
---|
68 | |
---|
69 | strcpy((char*)uncompr, "garbage"); |
---|
70 | |
---|
71 | err = uncompress(uncompr, &uncomprLen, compr, comprLen); |
---|
72 | CHECK_ERR(err, "uncompress"); |
---|
73 | |
---|
74 | if (strcmp((char*)uncompr, hello)) { |
---|
75 | fprintf(stderr, "bad uncompress\n"); |
---|
76 | exit(1); |
---|
77 | } else { |
---|
78 | printf("uncompress(): %s\n", (char *)uncompr); |
---|
79 | } |
---|
80 | } |
---|
81 | |
---|
82 | /* =========================================================================== |
---|
83 | * Test read/write of .gz files |
---|
84 | */ |
---|
85 | void test_gzio(fname, uncompr, uncomprLen) |
---|
86 | const char *fname; /* compressed file name */ |
---|
87 | Byte *uncompr; |
---|
88 | uLong uncomprLen; |
---|
89 | { |
---|
90 | #ifdef NO_GZCOMPRESS |
---|
91 | fprintf(stderr, "NO_GZCOMPRESS -- gz* functions cannot compress\n"); |
---|
92 | #else |
---|
93 | int err; |
---|
94 | int len = (int)strlen(hello)+1; |
---|
95 | gzFile file; |
---|
96 | z_off_t pos; |
---|
97 | |
---|
98 | file = gzopen(fname, "wb"); |
---|
99 | if (file == NULL) { |
---|
100 | fprintf(stderr, "gzopen error\n"); |
---|
101 | exit(1); |
---|
102 | } |
---|
103 | gzputc(file, 'h'); |
---|
104 | if (gzputs(file, "ello") != 4) { |
---|
105 | fprintf(stderr, "gzputs err: %s\n", gzerror(file, &err)); |
---|
106 | exit(1); |
---|
107 | } |
---|
108 | if (gzprintf(file, ", %s!", "hello") != 8) { |
---|
109 | fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err)); |
---|
110 | exit(1); |
---|
111 | } |
---|
112 | gzseek(file, 1L, SEEK_CUR); /* add one zero byte */ |
---|
113 | gzclose(file); |
---|
114 | |
---|
115 | file = gzopen(fname, "rb"); |
---|
116 | if (file == NULL) { |
---|
117 | fprintf(stderr, "gzopen error\n"); |
---|
118 | exit(1); |
---|
119 | } |
---|
120 | strcpy((char*)uncompr, "garbage"); |
---|
121 | |
---|
122 | if (gzread(file, uncompr, (unsigned)uncomprLen) != len) { |
---|
123 | fprintf(stderr, "gzread err: %s\n", gzerror(file, &err)); |
---|
124 | exit(1); |
---|
125 | } |
---|
126 | if (strcmp((char*)uncompr, hello)) { |
---|
127 | fprintf(stderr, "bad gzread: %s\n", (char*)uncompr); |
---|
128 | exit(1); |
---|
129 | } else { |
---|
130 | printf("gzread(): %s\n", (char*)uncompr); |
---|
131 | } |
---|
132 | |
---|
133 | pos = gzseek(file, -8L, SEEK_CUR); |
---|
134 | if (pos != 6 || gztell(file) != pos) { |
---|
135 | fprintf(stderr, "gzseek error, pos=%ld, gztell=%ld\n", |
---|
136 | (long)pos, (long)gztell(file)); |
---|
137 | exit(1); |
---|
138 | } |
---|
139 | |
---|
140 | if (gzgetc(file) != ' ') { |
---|
141 | fprintf(stderr, "gzgetc error\n"); |
---|
142 | exit(1); |
---|
143 | } |
---|
144 | |
---|
145 | if (gzungetc(' ', file) != ' ') { |
---|
146 | fprintf(stderr, "gzungetc error\n"); |
---|
147 | exit(1); |
---|
148 | } |
---|
149 | |
---|
150 | gzgets(file, (char*)uncompr, (int)uncomprLen); |
---|
151 | if (strlen((char*)uncompr) != 7) { /* " hello!" */ |
---|
152 | fprintf(stderr, "gzgets err after gzseek: %s\n", gzerror(file, &err)); |
---|
153 | exit(1); |
---|
154 | } |
---|
155 | if (strcmp((char*)uncompr, hello + 6)) { |
---|
156 | fprintf(stderr, "bad gzgets after gzseek\n"); |
---|
157 | exit(1); |
---|
158 | } else { |
---|
159 | printf("gzgets() after gzseek: %s\n", (char*)uncompr); |
---|
160 | } |
---|
161 | |
---|
162 | gzclose(file); |
---|
163 | #endif |
---|
164 | } |
---|
165 | |
---|
166 | /* =========================================================================== |
---|
167 | * Test deflate() with small buffers |
---|
168 | */ |
---|
169 | void test_deflate(compr, comprLen) |
---|
170 | Byte *compr; |
---|
171 | uLong comprLen; |
---|
172 | { |
---|
173 | z_stream c_stream; /* compression stream */ |
---|
174 | int err; |
---|
175 | uLong len = (uLong)strlen(hello)+1; |
---|
176 | |
---|
177 | c_stream.zalloc = (alloc_func)0; |
---|
178 | c_stream.zfree = (free_func)0; |
---|
179 | c_stream.opaque = (voidpf)0; |
---|
180 | |
---|
181 | err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION); |
---|
182 | CHECK_ERR(err, "deflateInit"); |
---|
183 | |
---|
184 | c_stream.next_in = (Bytef*)hello; |
---|
185 | c_stream.next_out = compr; |
---|
186 | |
---|
187 | while (c_stream.total_in != len && c_stream.total_out < comprLen) { |
---|
188 | c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */ |
---|
189 | err = deflate(&c_stream, Z_NO_FLUSH); |
---|
190 | CHECK_ERR(err, "deflate"); |
---|
191 | } |
---|
192 | /* Finish the stream, still forcing small buffers: */ |
---|
193 | for (;;) { |
---|
194 | c_stream.avail_out = 1; |
---|
195 | err = deflate(&c_stream, Z_FINISH); |
---|
196 | if (err == Z_STREAM_END) break; |
---|
197 | CHECK_ERR(err, "deflate"); |
---|
198 | } |
---|
199 | |
---|
200 | err = deflateEnd(&c_stream); |
---|
201 | CHECK_ERR(err, "deflateEnd"); |
---|
202 | } |
---|
203 | |
---|
204 | /* =========================================================================== |
---|
205 | * Test inflate() with small buffers |
---|
206 | */ |
---|
207 | void test_inflate(compr, comprLen, uncompr, uncomprLen) |
---|
208 | Byte *compr, *uncompr; |
---|
209 | uLong comprLen, uncomprLen; |
---|
210 | { |
---|
211 | int err; |
---|
212 | z_stream d_stream; /* decompression stream */ |
---|
213 | |
---|
214 | strcpy((char*)uncompr, "garbage"); |
---|
215 | |
---|
216 | d_stream.zalloc = (alloc_func)0; |
---|
217 | d_stream.zfree = (free_func)0; |
---|
218 | d_stream.opaque = (voidpf)0; |
---|
219 | |
---|
220 | d_stream.next_in = compr; |
---|
221 | d_stream.avail_in = 0; |
---|
222 | d_stream.next_out = uncompr; |
---|
223 | |
---|
224 | err = inflateInit(&d_stream); |
---|
225 | CHECK_ERR(err, "inflateInit"); |
---|
226 | |
---|
227 | while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) { |
---|
228 | d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */ |
---|
229 | err = inflate(&d_stream, Z_NO_FLUSH); |
---|
230 | if (err == Z_STREAM_END) break; |
---|
231 | CHECK_ERR(err, "inflate"); |
---|
232 | } |
---|
233 | |
---|
234 | err = inflateEnd(&d_stream); |
---|
235 | CHECK_ERR(err, "inflateEnd"); |
---|
236 | |
---|
237 | if (strcmp((char*)uncompr, hello)) { |
---|
238 | fprintf(stderr, "bad inflate\n"); |
---|
239 | exit(1); |
---|
240 | } else { |
---|
241 | printf("inflate(): %s\n", (char *)uncompr); |
---|
242 | } |
---|
243 | } |
---|
244 | |
---|
245 | /* =========================================================================== |
---|
246 | * Test deflate() with large buffers and dynamic change of compression level |
---|
247 | */ |
---|
248 | void test_large_deflate(compr, comprLen, uncompr, uncomprLen) |
---|
249 | Byte *compr, *uncompr; |
---|
250 | uLong comprLen, uncomprLen; |
---|
251 | { |
---|
252 | z_stream c_stream; /* compression stream */ |
---|
253 | int err; |
---|
254 | |
---|
255 | c_stream.zalloc = (alloc_func)0; |
---|
256 | c_stream.zfree = (free_func)0; |
---|
257 | c_stream.opaque = (voidpf)0; |
---|
258 | |
---|
259 | err = deflateInit(&c_stream, Z_BEST_SPEED); |
---|
260 | CHECK_ERR(err, "deflateInit"); |
---|
261 | |
---|
262 | c_stream.next_out = compr; |
---|
263 | c_stream.avail_out = (uInt)comprLen; |
---|
264 | |
---|
265 | /* At this point, uncompr is still mostly zeroes, so it should compress |
---|
266 | * very well: |
---|
267 | */ |
---|
268 | c_stream.next_in = uncompr; |
---|
269 | c_stream.avail_in = (uInt)uncomprLen; |
---|
270 | err = deflate(&c_stream, Z_NO_FLUSH); |
---|
271 | CHECK_ERR(err, "deflate"); |
---|
272 | if (c_stream.avail_in != 0) { |
---|
273 | fprintf(stderr, "deflate not greedy\n"); |
---|
274 | exit(1); |
---|
275 | } |
---|
276 | |
---|
277 | /* Feed in already compressed data and switch to no compression: */ |
---|
278 | deflateParams(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY); |
---|
279 | c_stream.next_in = compr; |
---|
280 | c_stream.avail_in = (uInt)comprLen/2; |
---|
281 | err = deflate(&c_stream, Z_NO_FLUSH); |
---|
282 | CHECK_ERR(err, "deflate"); |
---|
283 | |
---|
284 | /* Switch back to compressing mode: */ |
---|
285 | deflateParams(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED); |
---|
286 | c_stream.next_in = uncompr; |
---|
287 | c_stream.avail_in = (uInt)uncomprLen; |
---|
288 | err = deflate(&c_stream, Z_NO_FLUSH); |
---|
289 | CHECK_ERR(err, "deflate"); |
---|
290 | |
---|
291 | err = deflate(&c_stream, Z_FINISH); |
---|
292 | if (err != Z_STREAM_END) { |
---|
293 | fprintf(stderr, "deflate should report Z_STREAM_END\n"); |
---|
294 | exit(1); |
---|
295 | } |
---|
296 | err = deflateEnd(&c_stream); |
---|
297 | CHECK_ERR(err, "deflateEnd"); |
---|
298 | } |
---|
299 | |
---|
300 | /* =========================================================================== |
---|
301 | * Test inflate() with large buffers |
---|
302 | */ |
---|
303 | void test_large_inflate(compr, comprLen, uncompr, uncomprLen) |
---|
304 | Byte *compr, *uncompr; |
---|
305 | uLong comprLen, uncomprLen; |
---|
306 | { |
---|
307 | int err; |
---|
308 | z_stream d_stream; /* decompression stream */ |
---|
309 | |
---|
310 | strcpy((char*)uncompr, "garbage"); |
---|
311 | |
---|
312 | d_stream.zalloc = (alloc_func)0; |
---|
313 | d_stream.zfree = (free_func)0; |
---|
314 | d_stream.opaque = (voidpf)0; |
---|
315 | |
---|
316 | d_stream.next_in = compr; |
---|
317 | d_stream.avail_in = (uInt)comprLen; |
---|
318 | |
---|
319 | err = inflateInit(&d_stream); |
---|
320 | CHECK_ERR(err, "inflateInit"); |
---|
321 | |
---|
322 | for (;;) { |
---|
323 | d_stream.next_out = uncompr; /* discard the output */ |
---|
324 | d_stream.avail_out = (uInt)uncomprLen; |
---|
325 | err = inflate(&d_stream, Z_NO_FLUSH); |
---|
326 | if (err == Z_STREAM_END) break; |
---|
327 | CHECK_ERR(err, "large inflate"); |
---|
328 | } |
---|
329 | |
---|
330 | err = inflateEnd(&d_stream); |
---|
331 | CHECK_ERR(err, "inflateEnd"); |
---|
332 | |
---|
333 | if (d_stream.total_out != 2*uncomprLen + comprLen/2) { |
---|
334 | fprintf(stderr, "bad large inflate: %ld\n", d_stream.total_out); |
---|
335 | exit(1); |
---|
336 | } else { |
---|
337 | printf("large_inflate(): OK\n"); |
---|
338 | } |
---|
339 | } |
---|
340 | |
---|
341 | /* =========================================================================== |
---|
342 | * Test deflate() with full flush |
---|
343 | */ |
---|
344 | void test_flush(compr, comprLen) |
---|
345 | Byte *compr; |
---|
346 | uLong *comprLen; |
---|
347 | { |
---|
348 | z_stream c_stream; /* compression stream */ |
---|
349 | int err; |
---|
350 | uInt len = (uInt)strlen(hello)+1; |
---|
351 | |
---|
352 | c_stream.zalloc = (alloc_func)0; |
---|
353 | c_stream.zfree = (free_func)0; |
---|
354 | c_stream.opaque = (voidpf)0; |
---|
355 | |
---|
356 | err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION); |
---|
357 | CHECK_ERR(err, "deflateInit"); |
---|
358 | |
---|
359 | c_stream.next_in = (Bytef*)hello; |
---|
360 | c_stream.next_out = compr; |
---|
361 | c_stream.avail_in = 3; |
---|
362 | c_stream.avail_out = (uInt)*comprLen; |
---|
363 | err = deflate(&c_stream, Z_FULL_FLUSH); |
---|
364 | CHECK_ERR(err, "deflate"); |
---|
365 | |
---|
366 | compr[3]++; /* force an error in first compressed block */ |
---|
367 | c_stream.avail_in = len - 3; |
---|
368 | |
---|
369 | err = deflate(&c_stream, Z_FINISH); |
---|
370 | if (err != Z_STREAM_END) { |
---|
371 | CHECK_ERR(err, "deflate"); |
---|
372 | } |
---|
373 | err = deflateEnd(&c_stream); |
---|
374 | CHECK_ERR(err, "deflateEnd"); |
---|
375 | |
---|
376 | *comprLen = c_stream.total_out; |
---|
377 | } |
---|
378 | |
---|
379 | /* =========================================================================== |
---|
380 | * Test inflateSync() |
---|
381 | */ |
---|
382 | void test_sync(compr, comprLen, uncompr, uncomprLen) |
---|
383 | Byte *compr, *uncompr; |
---|
384 | uLong comprLen, uncomprLen; |
---|
385 | { |
---|
386 | int err; |
---|
387 | z_stream d_stream; /* decompression stream */ |
---|
388 | |
---|
389 | strcpy((char*)uncompr, "garbage"); |
---|
390 | |
---|
391 | d_stream.zalloc = (alloc_func)0; |
---|
392 | d_stream.zfree = (free_func)0; |
---|
393 | d_stream.opaque = (voidpf)0; |
---|
394 | |
---|
395 | d_stream.next_in = compr; |
---|
396 | d_stream.avail_in = 2; /* just read the zlib header */ |
---|
397 | |
---|
398 | err = inflateInit(&d_stream); |
---|
399 | CHECK_ERR(err, "inflateInit"); |
---|
400 | |
---|
401 | d_stream.next_out = uncompr; |
---|
402 | d_stream.avail_out = (uInt)uncomprLen; |
---|
403 | |
---|
404 | inflate(&d_stream, Z_NO_FLUSH); |
---|
405 | CHECK_ERR(err, "inflate"); |
---|
406 | |
---|
407 | d_stream.avail_in = (uInt)comprLen-2; /* read all compressed data */ |
---|
408 | err = inflateSync(&d_stream); /* but skip the damaged part */ |
---|
409 | CHECK_ERR(err, "inflateSync"); |
---|
410 | |
---|
411 | err = inflate(&d_stream, Z_FINISH); |
---|
412 | if (err != Z_DATA_ERROR) { |
---|
413 | fprintf(stderr, "inflate should report DATA_ERROR\n"); |
---|
414 | /* Because of incorrect adler32 */ |
---|
415 | exit(1); |
---|
416 | } |
---|
417 | err = inflateEnd(&d_stream); |
---|
418 | CHECK_ERR(err, "inflateEnd"); |
---|
419 | |
---|
420 | printf("after inflateSync(): hel%s\n", (char *)uncompr); |
---|
421 | } |
---|
422 | |
---|
423 | /* =========================================================================== |
---|
424 | * Test deflate() with preset dictionary |
---|
425 | */ |
---|
426 | void test_dict_deflate(compr, comprLen) |
---|
427 | Byte *compr; |
---|
428 | uLong comprLen; |
---|
429 | { |
---|
430 | z_stream c_stream; /* compression stream */ |
---|
431 | int err; |
---|
432 | |
---|
433 | c_stream.zalloc = (alloc_func)0; |
---|
434 | c_stream.zfree = (free_func)0; |
---|
435 | c_stream.opaque = (voidpf)0; |
---|
436 | |
---|
437 | err = deflateInit(&c_stream, Z_BEST_COMPRESSION); |
---|
438 | CHECK_ERR(err, "deflateInit"); |
---|
439 | |
---|
440 | err = deflateSetDictionary(&c_stream, |
---|
441 | (const Bytef*)dictionary, sizeof(dictionary)); |
---|
442 | CHECK_ERR(err, "deflateSetDictionary"); |
---|
443 | |
---|
444 | dictId = c_stream.adler; |
---|
445 | c_stream.next_out = compr; |
---|
446 | c_stream.avail_out = (uInt)comprLen; |
---|
447 | |
---|
448 | c_stream.next_in = (Bytef*)hello; |
---|
449 | c_stream.avail_in = (uInt)strlen(hello)+1; |
---|
450 | |
---|
451 | err = deflate(&c_stream, Z_FINISH); |
---|
452 | if (err != Z_STREAM_END) { |
---|
453 | fprintf(stderr, "deflate should report Z_STREAM_END\n"); |
---|
454 | exit(1); |
---|
455 | } |
---|
456 | err = deflateEnd(&c_stream); |
---|
457 | CHECK_ERR(err, "deflateEnd"); |
---|
458 | } |
---|
459 | |
---|
460 | /* =========================================================================== |
---|
461 | * Test inflate() with a preset dictionary |
---|
462 | */ |
---|
463 | void test_dict_inflate(compr, comprLen, uncompr, uncomprLen) |
---|
464 | Byte *compr, *uncompr; |
---|
465 | uLong comprLen, uncomprLen; |
---|
466 | { |
---|
467 | int err; |
---|
468 | z_stream d_stream; /* decompression stream */ |
---|
469 | |
---|
470 | strcpy((char*)uncompr, "garbage"); |
---|
471 | |
---|
472 | d_stream.zalloc = (alloc_func)0; |
---|
473 | d_stream.zfree = (free_func)0; |
---|
474 | d_stream.opaque = (voidpf)0; |
---|
475 | |
---|
476 | d_stream.next_in = compr; |
---|
477 | d_stream.avail_in = (uInt)comprLen; |
---|
478 | |
---|
479 | err = inflateInit(&d_stream); |
---|
480 | CHECK_ERR(err, "inflateInit"); |
---|
481 | |
---|
482 | d_stream.next_out = uncompr; |
---|
483 | d_stream.avail_out = (uInt)uncomprLen; |
---|
484 | |
---|
485 | for (;;) { |
---|
486 | err = inflate(&d_stream, Z_NO_FLUSH); |
---|
487 | if (err == Z_STREAM_END) break; |
---|
488 | if (err == Z_NEED_DICT) { |
---|
489 | if (d_stream.adler != dictId) { |
---|
490 | fprintf(stderr, "unexpected dictionary"); |
---|
491 | exit(1); |
---|
492 | } |
---|
493 | err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary, |
---|
494 | sizeof(dictionary)); |
---|
495 | } |
---|
496 | CHECK_ERR(err, "inflate with dict"); |
---|
497 | } |
---|
498 | |
---|
499 | err = inflateEnd(&d_stream); |
---|
500 | CHECK_ERR(err, "inflateEnd"); |
---|
501 | |
---|
502 | if (strcmp((char*)uncompr, hello)) { |
---|
503 | fprintf(stderr, "bad inflate with dict\n"); |
---|
504 | exit(1); |
---|
505 | } else { |
---|
506 | printf("inflate with dictionary: %s\n", (char *)uncompr); |
---|
507 | } |
---|
508 | } |
---|
509 | |
---|
510 | /* =========================================================================== |
---|
511 | * Usage: example [output.gz [input.gz]] |
---|
512 | */ |
---|
513 | |
---|
514 | int main(argc, argv) |
---|
515 | int argc; |
---|
516 | char *argv[]; |
---|
517 | { |
---|
518 | Byte *compr, *uncompr; |
---|
519 | uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */ |
---|
520 | uLong uncomprLen = comprLen; |
---|
521 | static const char* myVersion = ZLIB_VERSION; |
---|
522 | |
---|
523 | if (zlibVersion()[0] != myVersion[0]) { |
---|
524 | fprintf(stderr, "incompatible zlib version\n"); |
---|
525 | exit(1); |
---|
526 | |
---|
527 | } else if (strcmp(zlibVersion(), ZLIB_VERSION) != 0) { |
---|
528 | fprintf(stderr, "warning: different zlib version\n"); |
---|
529 | } |
---|
530 | |
---|
531 | printf("zlib version %s = 0x%04x, compile flags = 0x%lx\n", |
---|
532 | ZLIB_VERSION, ZLIB_VERNUM, zlibCompileFlags()); |
---|
533 | |
---|
534 | compr = (Byte*)calloc((uInt)comprLen, 1); |
---|
535 | uncompr = (Byte*)calloc((uInt)uncomprLen, 1); |
---|
536 | /* compr and uncompr are cleared to avoid reading uninitialized |
---|
537 | * data and to ensure that uncompr compresses well. |
---|
538 | */ |
---|
539 | if (compr == Z_NULL || uncompr == Z_NULL) { |
---|
540 | printf("out of memory\n"); |
---|
541 | exit(1); |
---|
542 | } |
---|
543 | test_compress(compr, comprLen, uncompr, uncomprLen); |
---|
544 | |
---|
545 | test_gzio((argc > 1 ? argv[1] : TESTFILE), |
---|
546 | uncompr, uncomprLen); |
---|
547 | |
---|
548 | test_deflate(compr, comprLen); |
---|
549 | test_inflate(compr, comprLen, uncompr, uncomprLen); |
---|
550 | |
---|
551 | test_large_deflate(compr, comprLen, uncompr, uncomprLen); |
---|
552 | test_large_inflate(compr, comprLen, uncompr, uncomprLen); |
---|
553 | |
---|
554 | test_flush(compr, &comprLen); |
---|
555 | test_sync(compr, comprLen, uncompr, uncomprLen); |
---|
556 | comprLen = uncomprLen; |
---|
557 | |
---|
558 | test_dict_deflate(compr, comprLen); |
---|
559 | test_dict_inflate(compr, comprLen, uncompr, uncomprLen); |
---|
560 | |
---|
561 | free(compr); |
---|
562 | free(uncompr); |
---|
563 | |
---|
564 | return 0; |
---|
565 | } |
---|