src/zlib/example.c

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

/* @(#) $Id$ */

#include <stdio.h>
#include "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 *fname,
                            Byte *uncompr, uLong 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 = (uLong)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(fname, uncompr, uncomprLen)
    const char *fname; /* compressed file name */
    Byte *uncompr;
    uLong uncomprLen;
{
#ifdef NO_GZCOMPRESS
    fprintf(stderr, "NO_GZCOMPRESS -- gz* functions cannot compress\n");
#else
    int err;
    int len = (int)strlen(hello)+1;
    gzFile file;
    z_off_t pos;

    file = gzopen(fname, "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(fname, "rb");
    if (file == NULL) {
        fprintf(stderr, "gzopen error\n");
        exit(1);
    }
    strcpy((char*)uncompr, "garbage");

    if (gzread(file, uncompr, (unsigned)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);
    }

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

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

    gzclose(file);
#endif
}

/* ===========================================================================
 * Test deflate() with small buffers
 */
void test_deflate(compr, comprLen)
    Byte *compr;
    uLong comprLen;
{
    z_stream c_stream; /* compression stream */
    int err;
    uLong len = (uLong)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 != 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;
    uInt len = (uInt)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");
    }

    printf("zlib version %s = 0x%04x, compile flags = 0x%lx\n",
            ZLIB_VERSION, ZLIB_VERNUM, zlibCompileFlags());

    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),
              uncompr, 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);

    free(compr);
    free(uncompr);

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