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

82.33

/test/switchlevels.c

/* Compresses a user-specified number of chunks from stdin into stdout as a single gzip stream.
 * Each chunk is compressed with a user-specified level.
 */

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

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

#if defined(_WIN32) || defined(__CYGWIN__)
#  include <fcntl.h>
#  include <io.h>
#  define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
#else
#  define SET_BINARY_MODE(file)
#endif

static int read_all(unsigned char *buf, size_t size) {
    size_t total_read = 0;
    while (total_read < size) {
        size_t n_read = fread(buf + total_read, 1, size - total_read, stdin);
        if (ferror(stdin)) {
            perror("fread\n");
            return 1;
        }
        if (n_read == 0) {
            fprintf(stderr, "Premature EOF\n");
            return 1;
        }
        total_read += n_read;
    }
    return 0;
}

static int write_all(unsigned char *buf, size_t size) {
    size_t total_written = 0;
    while (total_written < size) {
        size_t n_written = fwrite(buf + total_written, 1, size - total_written, stdout);
        if (ferror(stdout)) {
            perror("fwrite\n");
            return 1;
        }
        total_written += n_written;
    }
    return 0;
}

static int compress_chunk(PREFIX3(stream) *strm, int level, int size, int last) {
    int ret = 1;
    int err = 0;
    unsigned long compsize;
    unsigned char *buf;

    if (size <= 0) {
        fprintf(stderr, "compress_chunk() invalid size %d\n", size);
        goto done;
    }
    if (level < 0 || level > 9) {
        fprintf(stderr, "compress_chunk() invalid level %d\n", level);
        goto done;
    }

    compsize = PREFIX(deflateBound)(strm, size);
    buf = malloc(size + compsize);
    if (buf == NULL) {
        fprintf(stderr, "Out of memory\n");
        goto done;
    }
    if (read_all(buf, size) != 0) {
        goto free_buf;
    }

    /* Provide only output buffer to deflateParams(). It might need some space to flush the leftovers from the last
     * deflate(), but we don't want it to compress anything new. */
    strm->next_in = NULL;
    strm->avail_in = 0;
    strm->next_out = buf + size;
    strm->avail_out = compsize;
    err = PREFIX(deflateParams)(strm, level, Z_DEFAULT_STRATEGY);
    if (err != Z_OK) {
        fprintf(stderr, "deflateParams() failed with code %d\n", err);
        goto free_buf;
    }

    /* Provide input buffer to deflate(). */
    strm->next_in = buf;
    strm->avail_in = size;
    err = PREFIX(deflate)(strm, last ? Z_FINISH : Z_SYNC_FLUSH);
    if ((!last && err != Z_OK) || (last && err != Z_STREAM_END)) {
        fprintf(stderr, "deflate() failed with code %d\n", err);
        goto free_buf;
    }
    if (strm->avail_in != 0) {
        fprintf(stderr, "deflate() did not consume %" PRIu32 " bytes of input\n", strm->avail_in);
        goto free_buf;
    }
    if (write_all(buf + size, compsize - strm->avail_out) != 0) {
        goto free_buf;
    }
    ret = 0;

free_buf:
    free(buf);
done:
    return ret;
}

void show_help(void)
{
    printf("Usage: switchlevels [-w bits] level1 size1 [level2 size2 ...]\n\n"
           "  -w : window bits (8 to 15 for gzip, -8 to -15 for zlib)\n\n");
}

int main(int argc, char **argv) {
    int ret = EXIT_FAILURE;
    int err = 0;
    int size = 0;
    int level = Z_DEFAULT_COMPRESSION;
    int level_arg = 1;
    int window_bits = MAX_WBITS + 16;
    PREFIX3(stream) strm;


    if ((argc == 1) || (argc == 2 && strcmp(argv[1], "--help") == 0)) {
        show_help();
        return 0;
    }

    SET_BINARY_MODE(stdin);
    SET_BINARY_MODE(stdout);

    memset(&strm, 0, sizeof(strm));

    for (int i = 1; i < argc - 1; i++) {
        if (strcmp(argv[i], "-w") == 0 && i+1 < argc) {
            window_bits = atoi(argv[++i]);
        } else {
            level_arg = i;
            level = atoi(argv[i]);
            break;
        }
    }

    err = PREFIX(deflateInit2)(&strm, level, Z_DEFLATED, window_bits, 8, Z_DEFAULT_STRATEGY);
    if (err != Z_OK) {
        fprintf(stderr, "deflateInit() failed with code %d\n", err);
        goto done;
    }

    for (int i = level_arg; i < argc - 1; i += 2) {
        level = atoi(argv[i]);
        size = atoi(argv[i + 1]);
        if (compress_chunk(&strm, level, size, i + 2 >= argc - 1) != 0) {
            goto deflate_end;
        }
    }
    ret = EXIT_SUCCESS;

deflate_end:
    PREFIX(deflateEnd)(&strm);
done:
    return ret;
}

1	/* Compresses a user-specified number of chunks from stdin into stdout as a single gzip stream.
2	* Each chunk is compressed with a user-specified level.
3	*/
4
5	#include "zbuild.h"
6	#ifdef ZLIB_COMPAT
7	# include "zlib.h"
8	#else
9	# include "zlib-ng.h"
10	#endif
11
12	#include <inttypes.h>
13	#include <stdio.h>
14
15	#if defined(_WIN32) \|\| defined(__CYGWIN__)
16	# include <fcntl.h>
17	# include <io.h>
18	# define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
19	#else
20	# define SET_BINARY_MODE(file)
21	#endif
22
23	static int read_all(unsigned char *buf, size_t size) {	270✔
24	size_t total_read = 0;	80✔
25	while (total_read < size) {	540✔
26	size_t n_read = fread(buf + total_read, 1, size - total_read, stdin);	270✔
27	if (ferror(stdin)) {	270✔
28	perror("fread\n");	×
29	return 1;	×
30	}
31	if (n_read == 0) {	270✔
32	fprintf(stderr, "Premature EOF\n");	×
33	return 1;	×
34	}
35	total_read += n_read;	270✔
36	}	20✔
37	return 0;	20✔
38	}	20✔
39
40	static int write_all(unsigned char *buf, size_t size) {	270✔
41	size_t total_written = 0;	80✔
42	while (total_written < size) {	540✔
43	size_t n_written = fwrite(buf + total_written, 1, size - total_written, stdout);	270✔
44	if (ferror(stdout)) {	270✔
45	perror("fwrite\n");	×
46	return 1;	×
47	}
48	total_written += n_written;	270✔
49	}	20✔
50	return 0;	20✔
51	}	20✔
52
53	static int compress_chunk(PREFIX3(stream) *strm, int level, int size, int last) {	286✔
54	int ret = 1;	96✔
55	int err = 0;	96✔
56	unsigned long compsize;	96✔
57	unsigned char *buf;	96✔
58
59	if (size <= 0) {	286✔
60	fprintf(stderr, "compress_chunk() invalid size %d\n", size);	×
61	goto done;	×
62	}
63	if (level < 0 \|\| level > 9) {	286✔
64	fprintf(stderr, "compress_chunk() invalid level %d\n", level);	32!
65	goto done;	32✔
66	}
67
68	compsize = PREFIX(deflateBound)(strm, size);	286✔
69	buf = malloc(size + compsize);	286✔
70	if (buf == NULL) {	286✔
71	fprintf(stderr, "Out of memory\n");	×
72	goto done;	×
73	}
74	if (read_all(buf, size) != 0) {	286✔
UNCOV 75	goto free_buf;	×
76	}
77
78	/* Provide only output buffer to deflateParams(). It might need some space to flush the leftovers from the last
79	* deflate(), but we don't want it to compress anything new. */
80	strm->next_in = NULL;	286✔
81	strm->avail_in = 0;	286✔
82	strm->next_out = buf + size;	286✔
83	strm->avail_out = compsize;	286✔
84	err = PREFIX(deflateParams)(strm, level, Z_DEFAULT_STRATEGY);	286✔
85	if (err != Z_OK) {	286✔
86	fprintf(stderr, "deflateParams() failed with code %d\n", err);	×
87	goto free_buf;	×
88	}
89
90	/* Provide input buffer to deflate(). */
91	strm->next_in = buf;	286✔
92	strm->avail_in = size;	286✔
93	err = PREFIX(deflate)(strm, last ? Z_FINISH : Z_SYNC_FLUSH);	436✔
94	if ((!last && err != Z_OK) \|\| (last && err != Z_STREAM_END)) {	286✔
95	fprintf(stderr, "deflate() failed with code %d\n", err);	24!
96	goto free_buf;	24✔
97	}
98	if (strm->avail_in != 0) {	270✔
99	fprintf(stderr, "deflate() did not consume %" PRIu32 " bytes of input\n", strm->avail_in);	×
100	goto free_buf;	×
101	}
102	if (write_all(buf + size, compsize - strm->avail_out) != 0) {	270✔
UNCOV 103	goto free_buf;	×
104	}
105	ret = 0;	20✔
106
107	free_buf:	250✔
108	free(buf);	270✔
109	done:	250✔
110	return ret;	290✔
111	}	20✔
112
113	void show_help(void)	8✔
114	{
115	printf("Usage: switchlevels [-w bits] level1 size1 [level2 size2 ...]\n\n"	4✔
116	" -w : window bits (8 to 15 for gzip, -8 to -15 for zlib)\n\n");
117	}	2✔
118
119	int main(int argc, char **argv) {	135✔
120	int ret = EXIT_FAILURE;	40✔
121	int err = 0;	40✔
122	int size = 0;	40✔
123	int level = Z_DEFAULT_COMPRESSION;	40✔
124	int level_arg = 1;	40✔
125	int window_bits = MAX_WBITS + 16;	40✔
126	PREFIX3(stream) strm;	40✔
127
128
129	if ((argc == 1) \|\| (argc == 2 && strcmp(argv[1], "--help") == 0)) {	135✔
130	show_help();	8✔
131	return 0;	27✔
132	}
133
134	SET_BINARY_MODE(stdin);	28✔
135	SET_BINARY_MODE(stdout);	28✔
136
137	memset(&strm, 0, sizeof(strm));	40✔
138
139	for (int i = 1; i < argc - 1; i++) {	116✔
140	if (strcmp(argv[i], "-w") == 0 && i+1 < argc) {	108✔
141	window_bits = atoi(argv[++i]);	×
142	} else {
143	level_arg = i;	32✔
144	level = atoi(argv[i]);	40✔
145	break;	108✔
146	}
147	}
148
149	err = PREFIX(deflateInit2)(&strm, level, Z_DEFLATED, window_bits, 8, Z_DEFAULT_STRATEGY);	108✔
150	if (err != Z_OK) {	108✔
151	fprintf(stderr, "deflateInit() failed with code %d\n", err);	×
152	goto done;	×
153	}
154
155	for (int i = level_arg; i < argc - 1; i += 2) {	378✔
156	level = atoi(argv[i]);	270✔
157	size = atoi(argv[i + 1]);	270✔
158	if (compress_chunk(&strm, level, size, i + 2 >= argc - 1) != 0) {	270✔
UNCOV 159	goto deflate_end;	×
160	}
161	}	20✔
162	ret = EXIT_SUCCESS;	8✔
163
164	deflate_end:	100✔
165	PREFIX(deflateEnd)(&strm);	108✔
166	done:	16✔
167	return ret;	24✔
168	}	10✔

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