22071119879

Committed 16 Feb 2026 04:49PM UTC coverage: 94.322% (-0.5%) from 94.861%

Build # 22071119879

Build Type

Pull #1975

github

Committed by

web-flow

Commit Message

Merge 81c96c6b4 into 3f81a5cb4

Pull Request Pull Request #1975: Split CRC32 Braid and Chorba word types

Coverage Stats

7201 of 7711 branches covered (93.39%)

Branch coverage included in aggregate %.

182 of 182 new or added lines in 1 file covered. (100.0%)

48 existing lines in 13 files now uncovered.

10608 of 11170 relevant lines covered (94.97%)

167597172.44 hits per line

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

96.1

/test/fuzz/fuzzer_example_small.c

#include <stdio.h>
#include <assert.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;

/* ===========================================================================
 * Test deflate() with small buffers
 */
void test_deflate(unsigned char *compr, size_t comprLen) {
    PREFIX3(stream) c_stream; /* compression stream */
    int err;
    unsigned long len = (unsigned long)dataLen;

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

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

    c_stream.next_in = (z_const unsigned char *)data;
    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 = PREFIX(deflate)(&c_stream, Z_NO_FLUSH);
        CHECK_ERR(err, "deflate small 1");
    }
    /* Finish the stream, still forcing small buffers: */
    for (;;) {
        c_stream.avail_out = 1;
        err = PREFIX(deflate)(&c_stream, Z_FINISH);
        if (err == Z_STREAM_END)
            break;
        CHECK_ERR(err, "deflate small 2");
    }

    err = PREFIX(deflateEnd)(&c_stream);
    CHECK_ERR(err, "deflateEnd");
}

/* ===========================================================================
 * Test inflate() with small buffers
 */
void test_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 = 0;
    d_stream.next_out = uncompr;

    err = PREFIX(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 = PREFIX(inflate)(&d_stream, Z_NO_FLUSH);
        if (err == Z_STREAM_END)
            break;
        CHECK_ERR(err, "inflate");
    }

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

    if (memcmp(uncompr, data, dataLen)) {
        fprintf(stderr, "bad inflate\n");
        exit(1);
    }
}

int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size) {
    size_t comprLen = PREFIX(compressBound)(size);
    size_t uncomprLen = size;
    uint8_t *compr, *uncompr;

    /* Discard inputs larger than 1Mb. */
    static size_t kMaxSize = 1024 * 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_deflate(compr, comprLen);
    test_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
4	#include "zbuild.h"
5	#ifdef ZLIB_COMPAT
6	# include "zlib.h"
7	#else
8	# include "zlib-ng.h"
9	#endif
10
11	#define CHECK_ERR(err, msg) { \
12	if (err != Z_OK) { \
13	fprintf(stderr, "%s error: %d\n", msg, err); \
14	exit(1); \
15	} \
16	}
17
18	static const uint8_t *data;
19	static size_t dataLen;
20	static alloc_func zalloc = NULL;
21	static free_func zfree = NULL;
22
23	/* ===========================================================================
24	* Test deflate() with small buffers
25	*/
26	void test_deflate(unsigned char *compr, size_t comprLen) {	2,483✔
27	PREFIX3(stream) c_stream; /* compression stream */	736✔
28	int err;	736✔
29	unsigned long len = (unsigned long)dataLen;	2,483✔
30
31	c_stream.zalloc = zalloc;	2,483✔
32	c_stream.zfree = zfree;	2,483✔
33	c_stream.opaque = (void *)0;	2,483✔
34
35	err = PREFIX(deflateInit)(&c_stream, Z_DEFAULT_COMPRESSION);	2,483✔
36	CHECK_ERR(err, "deflateInit");	2,483✔
37
38	c_stream.next_in = (z_const unsigned char *)data;	2,483✔
39	c_stream.next_out = compr;	2,483✔
40
41	while (c_stream.total_in != len && c_stream.total_out < comprLen) {	55,859,405✔
42	c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */	55,856,922✔
43	err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH);	55,856,922✔
44	CHECK_ERR(err, "deflate small 1");	63,112,778✔
45	}
46	/* Finish the stream, still forcing small buffers: */
47	for (;;) {	2,356,374✔
48	c_stream.avail_out = 1;	8,026,450✔
49	err = PREFIX(deflate)(&c_stream, Z_FINISH);	8,026,450✔
50	if (err == Z_STREAM_END)	8,026,450✔
51	break;	184✔
52	CHECK_ERR(err, "deflate small 2");	8,023,967✔
53	}
54
55	err = PREFIX(deflateEnd)(&c_stream);	2,483✔
56	CHECK_ERR(err, "deflateEnd");	2,483✔
57	}	2,483✔
58
59	/* ===========================================================================
60	* Test inflate() with small buffers
61	*/
62	void test_inflate(unsigned char compr, size_t comprLen, unsigned char uncompr, size_t uncomprLen) {	2,483✔
63	int err;	736✔
64	PREFIX3(stream) d_stream; /* decompression stream */	736✔
65
66	d_stream.zalloc = zalloc;	2,483✔
67	d_stream.zfree = zfree;	2,483✔
68	d_stream.opaque = (void *)0;	2,483✔
69
70	d_stream.next_in = compr;	2,483✔
71	d_stream.avail_in = 0;	2,483✔
72	d_stream.next_out = uncompr;	2,483✔
73
74	err = PREFIX(inflateInit)(&d_stream);	2,483✔
75	CHECK_ERR(err, "inflateInit");	2,483✔
76
77	while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) {	49,963,160✔
78	d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */	49,961,229✔
79	err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH);	49,961,229✔
80	if (err == Z_STREAM_END)	49,961,229✔
81	break;
82	CHECK_ERR(err, "inflate");	49,961,781✔
83	}
84
85	err = PREFIX(inflateEnd)(&d_stream);	2,483✔
86	CHECK_ERR(err, "inflateEnd");	2,483✔
87
88	if (memcmp(uncompr, data, dataLen)) {	2,483✔
89	fprintf(stderr, "bad inflate\n");	×
UNCOV 90	exit(1);	×
91	}
92	}	2,483✔
93
94	int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size) {	2,484✔
95	size_t comprLen = PREFIX(compressBound)(size);	2,484✔
96	size_t uncomprLen = size;	736✔
97	uint8_t compr, uncompr;	736✔
98
99	/* Discard inputs larger than 1Mb. */
100	static size_t kMaxSize = 1024 * 1024;	552✔
101
102	if (size < 1 \|\| size > kMaxSize)	2,484✔
103	return 0;
104
105	data = d;	2,483✔
106	dataLen = size;	2,483✔
107	compr = (uint8_t *)calloc(1, comprLen);	2,483✔
108	uncompr = (uint8_t *)calloc(1, uncomprLen);	2,483✔
109
110	test_deflate(compr, comprLen);	2,483✔
111	test_inflate(compr, comprLen, uncompr, uncomprLen);	2,483✔
112
113	free(compr);	2,483✔
114	free(uncompr);	2,483✔
115
116	/* This function must return 0. */
117	return 0;	2,483✔
118	}	184✔

zlib-ng / zlib-ng / 22071119879

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