src/zlib/example.c

/* example.c -- usage example of the zlib compression library
 * Copyright (C) 1995-1998 Jean-loup Gailly.
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* @(#) $Id$ */

#include <stdio.h>
#include "../zlib/zlib.h"

#ifdef STDC
#  include <string.h>
#  include <stdlib.h>
#else
   extern void exit  OF((int));
#endif

#if defined(VMS) || defined(RISCOS)
#  define TESTFILE "foo-gz"
#else
#  define TESTFILE "foo.gz"
#endif

#define CHECK_ERR(err, msg) { \
    if (err != Z_OK) { \
        fprintf(stderr, "%s error: %d\n", msg, err); \
        exit(1); \
    } \
}

const char hello[] = "hello, hello!";
/* "hello world" would be more standard, but the repeated "hello"
 * stresses the compression code better, sorry...
 */

const char dictionary[] = "hello";
uLong dictId; /* Adler32 value of the dictionary */

void test_compress      OF((Byte *compr, uLong comprLen,
		            Byte *uncompr, uLong uncomprLen));
void test_gzio          OF((const char *out, const char *in,
		            Byte *uncompr, int uncomprLen));
void test_deflate       OF((Byte *compr, uLong comprLen));
void test_inflate       OF((Byte *compr, uLong comprLen,
		            Byte *uncompr, uLong uncomprLen));
void test_large_deflate OF((Byte *compr, uLong comprLen,
		            Byte *uncompr, uLong uncomprLen));
void test_large_inflate OF((Byte *compr, uLong comprLen,
		            Byte *uncompr, uLong uncomprLen));
void test_flush         OF((Byte *compr, uLong *comprLen));
void test_sync          OF((Byte *compr, uLong comprLen,
		            Byte *uncompr, uLong uncomprLen));
void test_dict_deflate  OF((Byte *compr, uLong comprLen));
void test_dict_inflate  OF((Byte *compr, uLong comprLen,
		            Byte *uncompr, uLong uncomprLen));
int  main               OF((int argc, char *argv[]));

/* ===========================================================================
 * Test compress() and uncompress()
 */
void test_compress(compr, comprLen, uncompr, uncomprLen)
    Byte *compr, *uncompr;
    uLong comprLen, uncomprLen;
{
    int err;
    uLong len = strlen(hello)+1;

    err = compress(compr, &comprLen, (const Bytef*)hello, len);
    CHECK_ERR(err, "compress");

    strcpy((char*)uncompr, "garbage");

    err = uncompress(uncompr, &uncomprLen, compr, comprLen);
    CHECK_ERR(err, "uncompress");

    if (strcmp((char*)uncompr, hello)) {
        fprintf(stderr, "bad uncompress\n");
	exit(1);
    } else {
        printf("uncompress(): %s\n", (char *)uncompr);
    }
}

/* ===========================================================================
 * Test read/write of .gz files
 */
void test_gzio(out, in, uncompr, uncomprLen)
    const char *out; /* compressed output file */
    const char *in;  /* compressed input file */
    Byte *uncompr;
    int  uncomprLen;
{
    int err;
    int len = strlen(hello)+1;
    gzFile file;
    z_off_t pos;

    file = gzopen(out, "wb");
    if (file == NULL) {
        fprintf(stderr, "gzopen error\n");
        exit(1);
    }
    gzputc(file, 'h');
    if (gzputs(file, "ello") != 4) {
        fprintf(stderr, "gzputs err: %s\n", gzerror(file, &err));
	exit(1);
    }
    if (gzprintf(file, ", %s!", "hello") != 8) {
        fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));
	exit(1);
    }
    gzseek(file, 1L, SEEK_CUR); /* add one zero byte */
    gzclose(file);

    file = gzopen(in, "rb");
    if (file == NULL) {
        fprintf(stderr, "gzopen error\n");
    }
    strcpy((char*)uncompr, "garbage");

    uncomprLen = gzread(file, uncompr, (unsigned)uncomprLen);
    if (uncomprLen != len) {
        fprintf(stderr, "gzread err: %s\n", gzerror(file, &err));
	exit(1);
    }
    if (strcmp((char*)uncompr, hello)) {
        fprintf(stderr, "bad gzread: %s\n", (char*)uncompr);
	exit(1);
    } else {
        printf("gzread(): %s\n", (char *)uncompr);
    }

    pos = gzseek(file, -8L, SEEK_CUR);
    if (pos != 6 || gztell(file) != pos) {
	fprintf(stderr, "gzseek error, pos=%ld, gztell=%ld\n",
		(long)pos, (long)gztell(file));
	exit(1);
    }

    if (gzgetc(file) != ' ') {
	fprintf(stderr, "gzgetc error\n");
	exit(1);
    }

    gzgets(file, (char*)uncompr, uncomprLen);
    uncomprLen = strlen((char*)uncompr);
    if (uncomprLen != 6) { /* "hello!" */
        fprintf(stderr, "gzgets err after gzseek: %s\n", gzerror(file, &err));
	exit(1);
    }
    if (strcmp((char*)uncompr, hello+7)) {
        fprintf(stderr, "bad gzgets after gzseek\n");
	exit(1);
    } else {
        printf("gzgets() after gzseek: %s\n", (char *)uncompr);
    }

    gzclose(file);
}

/* ===========================================================================
 * Test deflate() with small buffers
 */
void test_deflate(compr, comprLen)
    Byte *compr;
    uLong comprLen;
{
    z_stream c_stream; /* compression stream */
    int err;
    int len = strlen(hello)+1;

    c_stream.zalloc = (alloc_func)0;
    c_stream.zfree = (free_func)0;
    c_stream.opaque = (voidpf)0;

    err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
    CHECK_ERR(err, "deflateInit");

    c_stream.next_in  = (Bytef*)hello;
    c_stream.next_out = compr;

    while (c_stream.total_in != (uLong)len && c_stream.total_out < comprLen) {
        c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
        err = deflate(&c_stream, Z_NO_FLUSH);
        CHECK_ERR(err, "deflate");
    }
    /* Finish the stream, still forcing small buffers: */
    for (;;) {
        c_stream.avail_out = 1;
        err = deflate(&c_stream, Z_FINISH);
        if (err == Z_STREAM_END) break;
        CHECK_ERR(err, "deflate");
    }

    err = deflateEnd(&c_stream);
    CHECK_ERR(err, "deflateEnd");
}

/* ===========================================================================
 * Test inflate() with small buffers
 */
void test_inflate(compr, comprLen, uncompr, uncomprLen)
    Byte *compr, *uncompr;
    uLong comprLen, uncomprLen;
{
    int err;
    z_stream d_stream; /* decompression stream */

    strcpy((char*)uncompr, "garbage");

    d_stream.zalloc = (alloc_func)0;
    d_stream.zfree = (free_func)0;
    d_stream.opaque = (voidpf)0;

    d_stream.next_in  = compr;
    d_stream.avail_in = 0;
    d_stream.next_out = uncompr;

    err = inflateInit(&d_stream);
    CHECK_ERR(err, "inflateInit");

    while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) {
        d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
        err = inflate(&d_stream, Z_NO_FLUSH);
        if (err == Z_STREAM_END) break;
        CHECK_ERR(err, "inflate");
    }

    err = inflateEnd(&d_stream);
    CHECK_ERR(err, "inflateEnd");

    if (strcmp((char*)uncompr, hello)) {
        fprintf(stderr, "bad inflate\n");
	exit(1);
    } else {
        printf("inflate(): %s\n", (char *)uncompr);
    }
}

/* ===========================================================================
 * Test deflate() with large buffers and dynamic change of compression level
 */
void test_large_deflate(compr, comprLen, uncompr, uncomprLen)
    Byte *compr, *uncompr;
    uLong comprLen, uncomprLen;
{
    z_stream c_stream; /* compression stream */
    int err;

    c_stream.zalloc = (alloc_func)0;
    c_stream.zfree = (free_func)0;
    c_stream.opaque = (voidpf)0;

    err = deflateInit(&c_stream, Z_BEST_SPEED);
    CHECK_ERR(err, "deflateInit");

    c_stream.next_out = compr;
    c_stream.avail_out = (uInt)comprLen;

    /* At this point, uncompr is still mostly zeroes, so it should compress
     * very well:
     */
    c_stream.next_in = uncompr;
    c_stream.avail_in = (uInt)uncomprLen;
    err = deflate(&c_stream, Z_NO_FLUSH);
    CHECK_ERR(err, "deflate");
    if (c_stream.avail_in != 0) {
        fprintf(stderr, "deflate not greedy\n");
	exit(1);
    }

    /* Feed in already compressed data and switch to no compression: */
    deflateParams(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
    c_stream.next_in = compr;
    c_stream.avail_in = (uInt)comprLen/2;
    err = deflate(&c_stream, Z_NO_FLUSH);
    CHECK_ERR(err, "deflate");

    /* Switch back to compressing mode: */
    deflateParams(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED);
    c_stream.next_in = uncompr;
    c_stream.avail_in = (uInt)uncomprLen;
    err = deflate(&c_stream, Z_NO_FLUSH);
    CHECK_ERR(err, "deflate");

    err = deflate(&c_stream, Z_FINISH);
    if (err != Z_STREAM_END) {
        fprintf(stderr, "deflate should report Z_STREAM_END\n");
	exit(1);
    }
    err = deflateEnd(&c_stream);
    CHECK_ERR(err, "deflateEnd");
}

/* ===========================================================================
 * Test inflate() with large buffers
 */
void test_large_inflate(compr, comprLen, uncompr, uncomprLen)
    Byte *compr, *uncompr;
    uLong comprLen, uncomprLen;
{
    int err;
    z_stream d_stream; /* decompression stream */

    strcpy((char*)uncompr, "garbage");

    d_stream.zalloc = (alloc_func)0;
    d_stream.zfree = (free_func)0;
    d_stream.opaque = (voidpf)0;

    d_stream.next_in  = compr;
    d_stream.avail_in = (uInt)comprLen;

    err = inflateInit(&d_stream);
    CHECK_ERR(err, "inflateInit");

    for (;;) {
        d_stream.next_out = uncompr;            /* discard the output */
	d_stream.avail_out = (uInt)uncomprLen;
        err = inflate(&d_stream, Z_NO_FLUSH);
        if (err == Z_STREAM_END) break;
        CHECK_ERR(err, "large inflate");
    }

    err = inflateEnd(&d_stream);
    CHECK_ERR(err, "inflateEnd");

    if (d_stream.total_out != 2*uncomprLen + comprLen/2) {
        fprintf(stderr, "bad large inflate: %ld\n", d_stream.total_out);
	exit(1);
    } else {
        printf("large_inflate(): OK\n");
    }
}

/* ===========================================================================
 * Test deflate() with full flush
 */
void test_flush(compr, comprLen)
    Byte *compr;
    uLong *comprLen;
{
    z_stream c_stream; /* compression stream */
    int err;
    int len = strlen(hello)+1;

    c_stream.zalloc = (alloc_func)0;
    c_stream.zfree = (free_func)0;
    c_stream.opaque = (voidpf)0;

    err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
    CHECK_ERR(err, "deflateInit");

    c_stream.next_in  = (Bytef*)hello;
    c_stream.next_out = compr;
    c_stream.avail_in = 3;
    c_stream.avail_out = (uInt)*comprLen;
    err = deflate(&c_stream, Z_FULL_FLUSH);
    CHECK_ERR(err, "deflate");

    compr[3]++; /* force an error in first compressed block */
    c_stream.avail_in = len - 3;

    err = deflate(&c_stream, Z_FINISH);
    if (err != Z_STREAM_END) {
        CHECK_ERR(err, "deflate");
    }
    err = deflateEnd(&c_stream);
    CHECK_ERR(err, "deflateEnd");

    *comprLen = c_stream.total_out;
}

/* ===========================================================================
 * Test inflateSync()
 */
void test_sync(compr, comprLen, uncompr, uncomprLen)
    Byte *compr, *uncompr;
    uLong comprLen, uncomprLen;
{
    int err;
    z_stream d_stream; /* decompression stream */

    strcpy((char*)uncompr, "garbage");

    d_stream.zalloc = (alloc_func)0;
    d_stream.zfree = (free_func)0;
    d_stream.opaque = (voidpf)0;

    d_stream.next_in  = compr;
    d_stream.avail_in = 2; /* just read the zlib header */

    err = inflateInit(&d_stream);
    CHECK_ERR(err, "inflateInit");

    d_stream.next_out = uncompr;
    d_stream.avail_out = (uInt)uncomprLen;

    inflate(&d_stream, Z_NO_FLUSH);
    CHECK_ERR(err, "inflate");

    d_stream.avail_in = (uInt)comprLen-2;   /* read all compressed data */
    err = inflateSync(&d_stream);           /* but skip the damaged part */
    CHECK_ERR(err, "inflateSync");

    err = inflate(&d_stream, Z_FINISH);
    if (err != Z_DATA_ERROR) {
        fprintf(stderr, "inflate should report DATA_ERROR\n");
        /* Because of incorrect adler32 */
	exit(1);
    }
    err = inflateEnd(&d_stream);
    CHECK_ERR(err, "inflateEnd");

    printf("after inflateSync(): hel%s\n", (char *)uncompr);
}

/* ===========================================================================
 * Test deflate() with preset dictionary
 */
void test_dict_deflate(compr, comprLen)
    Byte *compr;
    uLong comprLen;
{
    z_stream c_stream; /* compression stream */
    int err;

    c_stream.zalloc = (alloc_func)0;
    c_stream.zfree = (free_func)0;
    c_stream.opaque = (voidpf)0;

    err = deflateInit(&c_stream, Z_BEST_COMPRESSION);
    CHECK_ERR(err, "deflateInit");

    err = deflateSetDictionary(&c_stream,
			       (const Bytef*)dictionary, sizeof(dictionary));
    CHECK_ERR(err, "deflateSetDictionary");

    dictId = c_stream.adler;
    c_stream.next_out = compr;
    c_stream.avail_out = (uInt)comprLen;

    c_stream.next_in = (Bytef*)hello;
    c_stream.avail_in = (uInt)strlen(hello)+1;

    err = deflate(&c_stream, Z_FINISH);
    if (err != Z_STREAM_END) {
        fprintf(stderr, "deflate should report Z_STREAM_END\n");
	exit(1);
    }
    err = deflateEnd(&c_stream);
    CHECK_ERR(err, "deflateEnd");
}

/* ===========================================================================
 * Test inflate() with a preset dictionary
 */
void test_dict_inflate(compr, comprLen, uncompr, uncomprLen)
    Byte *compr, *uncompr;
    uLong comprLen, uncomprLen;
{
    int err;
    z_stream d_stream; /* decompression stream */

    strcpy((char*)uncompr, "garbage");

    d_stream.zalloc = (alloc_func)0;
    d_stream.zfree = (free_func)0;
    d_stream.opaque = (voidpf)0;

    d_stream.next_in  = compr;
    d_stream.avail_in = (uInt)comprLen;

    err = inflateInit(&d_stream);
    CHECK_ERR(err, "inflateInit");

    d_stream.next_out = uncompr;
    d_stream.avail_out = (uInt)uncomprLen;

    for (;;) {
        err = inflate(&d_stream, Z_NO_FLUSH);
        if (err == Z_STREAM_END) break;
	if (err == Z_NEED_DICT) {
	    if (d_stream.adler != dictId) {
		fprintf(stderr, "unexpected dictionary");
		exit(1);
	    }
	    err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,
				       sizeof(dictionary));
	}
        CHECK_ERR(err, "inflate with dict");
    }

    err = inflateEnd(&d_stream);
    CHECK_ERR(err, "inflateEnd");

    if (strcmp((char*)uncompr, hello)) {
        fprintf(stderr, "bad inflate with dict\n");
	exit(1);
    } else {
        printf("inflate with dictionary: %s\n", (char *)uncompr);
    }
}

/* ===========================================================================
 * Usage:  example [output.gz  [input.gz]]
 */

int main(argc, argv)
    int argc;
    char *argv[];
{
    Byte *compr, *uncompr;
    uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */
    uLong uncomprLen = comprLen;
    static const char* myVersion = ZLIB_VERSION;

    if (zlibVersion()[0] != myVersion[0]) {
        fprintf(stderr, "incompatible zlib version\n");
        exit(1);

    } else if (strcmp(zlibVersion(), ZLIB_VERSION) != 0) {
        fprintf(stderr, "warning: different zlib version\n");
    }

    compr    = (Byte*)calloc((uInt)comprLen, 1);
    uncompr  = (Byte*)calloc((uInt)uncomprLen, 1);
    /* compr and uncompr are cleared to avoid reading uninitialized
     * data and to ensure that uncompr compresses well.
     */
    if (compr == Z_NULL || uncompr == Z_NULL) {
        printf("out of memory\n");
	exit(1);
    }
    test_compress(compr, comprLen, uncompr, uncomprLen);

    test_gzio((argc > 1 ? argv[1] : TESTFILE),
              (argc > 2 ? argv[2] : TESTFILE),
	      uncompr, (int)uncomprLen);

    test_deflate(compr, comprLen);
    test_inflate(compr, comprLen, uncompr, uncomprLen);

    test_large_deflate(compr, comprLen, uncompr, uncomprLen);
    test_large_inflate(compr, comprLen, uncompr, uncomprLen);

    test_flush(compr, &comprLen);
    test_sync(compr, comprLen, uncompr, uncomprLen);
    comprLen = uncomprLen;

    test_dict_deflate(compr, comprLen);
    test_dict_inflate(compr, comprLen, uncompr, uncomprLen);

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