[pcsx_rearmed.git] / deps / libchdr / deps / zstd-1.5.6 / zlibWrapper / examples / example_original.c

/* example.c -- usage example of the zlib compression library
 */
/*
 Copyright (c) 1995-2006, 2011 Jean-loup Gailly

This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not
   claim that you wrote the original software. If you use this software
   in a product, an acknowledgement in the product documentation would be
   appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
   misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/

/* @(#) $Id$ */

#include "zlib.h"
#include <stdio.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); \
    } \
}

z_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_deflate       _Z_OF((Byte *compr, uLong comprLen));
void test_inflate       _Z_OF((Byte *compr, uLong comprLen,
                            Byte *uncompr, uLong uncomprLen));
void test_large_deflate _Z_OF((Byte *compr, uLong comprLen,
                            Byte *uncompr, uLong uncomprLen));
void test_large_inflate _Z_OF((Byte *compr, uLong comprLen,
                            Byte *uncompr, uLong uncomprLen));
void test_flush         _Z_OF((Byte *compr, uLong *comprLen));
void test_sync          _Z_OF((Byte *compr, uLong comprLen,
                            Byte *uncompr, uLong uncomprLen));
void test_dict_deflate  _Z_OF((Byte *compr, uLong comprLen));
void test_dict_inflate  _Z_OF((Byte *compr, uLong comprLen,
                            Byte *uncompr, uLong uncomprLen));
int  main               _Z_OF((int argc, char *argv[]));


#ifdef Z_SOLO

void *myalloc _Z_OF((void *, unsigned, unsigned));
void myfree _Z_OF((void *, void *));

void *myalloc(q, n, m)
    void *q;
    unsigned n, m;
{
    q = Z_NULL;
    return calloc(n, m);
}

void myfree(void *q, void *p)
{
    q = Z_NULL;
    free(p);
}

static alloc_func zalloc = myalloc;
static free_func zfree = myfree;

#else /* !Z_SOLO */

static alloc_func zalloc = (alloc_func)0;
static free_func zfree = (free_func)0;

void test_compress      _Z_OF((Byte *compr, uLong comprLen,
                            Byte *uncompr, uLong uncomprLen));
void test_gzio          _Z_OF((const char *fname,
                            Byte *uncompr, uLong uncomprLen));

/* ===========================================================================
 * Test compress() and uncompress()
 */
void test_compress(Byte *compr, uLong comprLen, Byte *uncompr, uLong 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(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
}

#endif /* Z_SOLO */

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

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

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

    c_stream.next_in  = (z_const unsigned char *)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(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen)
{
    int err;
    z_stream d_stream; /* decompression stream */

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

    d_stream.zalloc = zalloc;
    d_stream.zfree = zfree;
    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(Byte *compr, uLong comprLen, Byte *uncompr,
    uLong uncomprLen)
{
    z_stream c_stream; /* compression stream */
    int err;

    c_stream.zalloc = zalloc;
    c_stream.zfree = zfree;
    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(Byte *compr, uLong comprLen, Byte *uncompr,
    uLong uncomprLen)
{
    int err;
    z_stream d_stream; /* decompression stream */

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

    d_stream.zalloc = zalloc;
    d_stream.zfree = zfree;
    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(Byte *compr, uLong comprLen)
{
    z_stream c_stream; /* compression stream */
    int err;
    uInt len = (uInt)strlen(hello)+1;

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

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

    c_stream.next_in  = (z_const unsigned char *)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(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen)
{
    int err;
    z_stream d_stream; /* decompression stream */

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

    d_stream.zalloc = zalloc;
    d_stream.zfree = zfree;
    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(Byte *compr, uLong comprLen)
{
    z_stream c_stream; /* compression stream */
    int err;

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

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

    err = deflateSetDictionary(&c_stream,
                (const Bytef*)dictionary, (int)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 = (z_const unsigned char *)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(Byte *compr, uLong comprLen, Byte *uncompr,
    uLong uncomprLen)
{
    int err;
    z_stream d_stream; /* decompression stream */

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

    d_stream.zalloc = zalloc;
    d_stream.zfree = zfree;
    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,
                                       (int)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(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);
    }

#ifdef Z_SOLO
    argc = strlen(argv[0]);
#else
    test_compress(compr, comprLen, uncompr, uncomprLen);

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

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