21758018679

Committed 06 Feb 2026 04:33PM UTC coverage: 94.713% (-0.02%) from 94.736%

Build # 21758018679

Build Type

Pull #2139

github

Committed by

web-flow

Commit Message

Merge e366b2b5e into 98539ef92

Pull Request Pull Request #2139: Add compile-time feature detection macros

Coverage Stats

8863 of 9520 branches covered (93.1%)

Branch coverage included in aggregate %.

129 of 129 new or added lines in 2 files covered. (100.0%)

19 existing lines in 8 files now uncovered.

12457 of 12990 relevant lines covered (95.9%)

260794771.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.09

/test/fuzz/fuzzer_example_large.c

#include <stdio.h>
#include <assert.h>
#include <inttypes.h>

#include "zbuild.h"
#ifdef ZLIB_COMPAT
#  include "zlib.h"
#else
#  include "zlib-ng.h"
#endif

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

static const uint8_t *data;
static size_t dataLen;
static alloc_func zalloc = NULL;
static free_func zfree = NULL;
static unsigned int diff;

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

    c_stream.zalloc = zalloc;
    c_stream.zfree = zfree;
    c_stream.opaque = (void *)0;

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

    c_stream.next_out = compr;
    c_stream.avail_out = (unsigned int)comprLen;

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

    /* Feed in already compressed data and switch to no compression: */
    PREFIX(deflateParams)(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
    c_stream.next_in = compr;
    diff = (unsigned int)(c_stream.next_out - compr);
    c_stream.avail_in = diff;
    err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH);
    CHECK_ERR(err, "deflate large 2");

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

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

/* ===========================================================================
 * Test inflate() with large buffers
 */
void test_large_inflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) {
    int err;
    PREFIX3(stream) d_stream; /* decompression stream */

    d_stream.zalloc = zalloc;
    d_stream.zfree = zfree;
    d_stream.opaque = (void *)0;

    d_stream.next_in = compr;
    d_stream.avail_in = (unsigned int)comprLen;

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

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

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

    if (d_stream.total_out != 2 * uncomprLen + diff) {
        fprintf(stderr, "bad large inflate: %" PRIu64 "\n", (uint64_t)d_stream.total_out);
        exit(1);
    }
}

int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size) {
    size_t comprLen = 100 + 3 * size;
    size_t uncomprLen = comprLen;
    uint8_t *compr, *uncompr;

    /* Discard inputs larger than 512Kb. */
    static size_t kMaxSize = 512 * 1024;

    if (size < 1 || size > kMaxSize)
        return 0;

    data = d;
    dataLen = size;
    compr = (uint8_t *)calloc(1, comprLen);
    uncompr = (uint8_t *)calloc(1, uncomprLen);

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

    free(compr);
    free(uncompr);

    /* This function must return 0. */
    return 0;
}

1	#include <stdio.h>
2	#include <assert.h>
3	#include <inttypes.h>
4
5	#include "zbuild.h"
6	#ifdef ZLIB_COMPAT
7	# include "zlib.h"
8	#else
9	# include "zlib-ng.h"
10	#endif
11
12	#define CHECK_ERR(err, msg) { \
13	if (err != Z_OK) { \
14	fprintf(stderr, "%s error: %d\n", msg, err); \
15	exit(1); \
16	} \
17	}
18
19	static const uint8_t *data;
20	static size_t dataLen;
21	static alloc_func zalloc = NULL;
22	static free_func zfree = NULL;
23	static unsigned int diff;
24
25	/* ===========================================================================
26	* Test deflate() with large buffers and dynamic change of compression level
27	*/
28	void test_large_deflate(unsigned char compr, size_t comprLen, unsigned char uncompr, size_t uncomprLen) {	4,317✔
29	PREFIX3(stream) c_stream; /* compression stream */	1,656✔
30	int err;	1,656✔
31
32	c_stream.zalloc = zalloc;	4,317✔
33	c_stream.zfree = zfree;	4,317✔
34	c_stream.opaque = (void *)0;	4,317✔
35
36	err = PREFIX(deflateInit)(&c_stream, Z_BEST_COMPRESSION);	4,317✔
37	CHECK_ERR(err, "deflateInit");	4,317✔
38
39	c_stream.next_out = compr;	4,317✔
40	c_stream.avail_out = (unsigned int)comprLen;	4,317✔
41
42	/* At this point, uncompr is still mostly zeroes, so it should compress
43	* very well:
44	*/
45	c_stream.next_in = uncompr;	4,317✔
46	c_stream.avail_in = (unsigned int)uncomprLen;	4,317✔
47	err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH);	4,317✔
48	CHECK_ERR(err, "deflate large 1");	4,317✔
49	if (c_stream.avail_in != 0) {	4,317✔
50	fprintf(stderr, "deflate not greedy\n");	×
51	exit(1);	×
52	}
53
54	/* Feed in already compressed data and switch to no compression: */
55	PREFIX(deflateParams)(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);	4,317✔
56	c_stream.next_in = compr;	4,317✔
57	diff = (unsigned int)(c_stream.next_out - compr);	4,317✔
58	c_stream.avail_in = diff;	4,317✔
59	err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH);	4,317✔
60	CHECK_ERR(err, "deflate large 2");	4,317✔
61
62	/* Switch back to compressing mode: */
63	PREFIX(deflateParams)(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED);	4,317✔
64	c_stream.next_in = uncompr;	4,317✔
65	c_stream.avail_in = (unsigned int)uncomprLen;	4,317✔
66	err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH);	4,317✔
67	CHECK_ERR(err, "deflate large 3");	4,317✔
68
69	err = PREFIX(deflate)(&c_stream, Z_FINISH);	4,317✔
70	if (err != Z_STREAM_END) {	4,317✔
71	fprintf(stderr, "deflate large should report Z_STREAM_END\n");	×
72	exit(1);	×
73	}
74	err = PREFIX(deflateEnd)(&c_stream);	4,317✔
75	CHECK_ERR(err, "deflateEnd");	4,317✔
76	}	4,317✔
77
78	/* ===========================================================================
79	* Test inflate() with large buffers
80	*/
81	void test_large_inflate(unsigned char compr, size_t comprLen, unsigned char uncompr, size_t uncomprLen) {	4,317✔
82	int err;	1,656✔
83	PREFIX3(stream) d_stream; /* decompression stream */	1,656✔
84
85	d_stream.zalloc = zalloc;	4,317✔
86	d_stream.zfree = zfree;	4,317✔
87	d_stream.opaque = (void *)0;	4,317✔
88
89	d_stream.next_in = compr;	4,317✔
90	d_stream.avail_in = (unsigned int)comprLen;	4,317✔
91
92	err = PREFIX(inflateInit)(&d_stream);	4,317✔
93	CHECK_ERR(err, "inflateInit");	4,317✔
94
95	for (;;) {	5,244✔
96	d_stream.next_out = uncompr; /* discard the output */	12,951✔
97	d_stream.avail_out = (unsigned int)uncomprLen;	12,951✔
98	err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH);	12,951✔
99	if (err == Z_STREAM_END)	12,951✔
100	break;	644✔
101	CHECK_ERR(err, "large inflate");	8,634✔
102	}
103
104	err = PREFIX(inflateEnd)(&d_stream);	4,317✔
105	CHECK_ERR(err, "inflateEnd");	4,317✔
106
107	if (d_stream.total_out != 2 * uncomprLen + diff) {	4,317✔
108	fprintf(stderr, "bad large inflate: %" PRIu64 "\n", (uint64_t)d_stream.total_out);	×
UNCOV 109	exit(1);	×
110	}
111	}	4,317✔
112
113	int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size) {	4,371✔
114	size_t comprLen = 100 + 3 * size;	4,371✔
115	size_t uncomprLen = comprLen;	1,767✔
116	uint8_t compr, uncompr;	1,674✔
117
118	/* Discard inputs larger than 512Kb. */
119	static size_t kMaxSize = 512 * 1024;	1,116✔
120
121	if (size < 1 \|\| size > kMaxSize)	4,371✔
122	return 0;	7✔
123
124	data = d;	4,317✔
125	dataLen = size;	4,317✔
126	compr = (uint8_t *)calloc(1, comprLen);	4,317✔
127	uncompr = (uint8_t *)calloc(1, uncomprLen);	4,317✔
128
129	test_large_deflate(compr, comprLen, uncompr, uncomprLen);	4,317✔
130	test_large_inflate(compr, comprLen, uncompr, uncomprLen);	4,317✔
131
132	free(compr);	4,317✔
133	free(uncompr);	4,317✔
134
135	/* This function must return 0. */
136	return 0;	4,317✔
137	}	651✔

zlib-ng / zlib-ng / 21758018679

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous