src/zlib/example.c

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


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

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