[wxWidgets.git] / 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
 */

/* @(#) $Id$ */

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