Rename z variable to status, in C code

This commit is contained in:
Nigel Tao committed 2018-12-28 16:14:03 +11:00
1 parent ce96837b40
commit dd94ad3821
15 files changed
+504 -488

No files matched your search

+3 -3
View File
@@ -57,9 +57,9 @@ uint8_t src_buffer[SRC_BUFFER_SIZE];
int main(int argc, char** argv) {
wuffs_crc32__ieee_hasher h = ((wuffs_crc32__ieee_hasher){});
wuffs_base__status z = h.check_wuffs_version(sizeof h, WUFFS_VERSION);
if (z) {
fprintf(stderr, "%s\n", z);
const char* status = h.check_wuffs_version(sizeof h, WUFFS_VERSION);
if (status) {
fprintf(stderr, "%s\n", status);
return 1;
}
+21 -20
View File
@@ -264,8 +264,8 @@ const char* try_allocate(wuffs_gif__decoder* dec,
}
const char* allocate(wuffs_gif__decoder* dec, wuffs_base__image_config* ic) {
const char* z = try_allocate(dec, ic);
if (z) {
const char* status = try_allocate(dec, ic);
if (status) {
free(printbuf.ptr);
printbuf = ((wuffs_base__slice_u8){});
free(workbuf.ptr);
@@ -278,15 +278,15 @@ const char* allocate(wuffs_gif__decoder* dec, wuffs_base__image_config* ic) {
curr_dst_buffer = NULL;
dst_len = 0;
}
return z;
return status;
}
const char* play() {
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_base__status z =
wuffs_base__status status =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
return z;
if (status) {
return status;
}
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
@@ -305,9 +305,9 @@ const char* play() {
if (first_play) {
wuffs_base__image_config ic = ((wuffs_base__image_config){});
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z) {
return z;
status = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (status) {
return status;
}
if (!wuffs_base__image_config__is_valid(&ic)) {
return "invalid image configuration";
@@ -327,9 +327,9 @@ const char* play() {
if (msg) {
return msg;
}
z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg, pixbuf);
if (z) {
return z;
status = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg, pixbuf);
if (status) {
return status;
}
memset(pixbuf.ptr, 0, pixbuf.len);
memset(curr_dst_buffer, 0, dst_len);
@@ -337,13 +337,13 @@ const char* play() {
while (1) {
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
wuffs_base__status z =
wuffs_base__status status =
wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader);
if (z) {
if (z == wuffs_base__warning__end_of_data) {
if (status) {
if (status == wuffs_base__warning__end_of_data) {
break;
}
return z;
return status;
}
switch (wuffs_base__frame_config__disposal(&fc)) {
@@ -353,12 +353,13 @@ const char* play() {
}
}
z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader, workbuf, NULL);
if (z) {
if (z == wuffs_base__warning__end_of_data) {
status =
wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader, workbuf, NULL);
if (status) {
if (status == wuffs_base__warning__end_of_data) {
break;
}
return z;
return status;
}
compose(&pb, wuffs_base__frame_config__bounds(&fc));
+6 -6
View File
@@ -79,16 +79,16 @@ static const char* decode() {
if (!dec) {
return "out of memory";
}
wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version(
const char* status = wuffs_deflate__decoder__check_wuffs_version(
dec, sizeof__wuffs_deflate__decoder(), WUFFS_VERSION);
if (z) {
if (status) {
free(dec);
return z;
return status;
}
z = wuffs_deflate__decoder__decode(dec, dst_writer, src_reader);
if (z) {
status = wuffs_deflate__decoder__decode(dec, dst_writer, src_reader);
if (status) {
free(dec);
return z;
return status;
}
ignore_return_value(write(1, dst.data.ptr, dst.meta.wi));
free(dec);
+7 -7
View File
@@ -75,10 +75,10 @@ static void ignore_return_value(int ignored) {}
static const char* decode() {
wuffs_gzip__decoder dec = ((wuffs_gzip__decoder){});
wuffs_base__status z =
const char* status =
wuffs_gzip__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
return z;
if (status) {
return status;
}
wuffs_base__io_buffer dst = ((wuffs_base__io_buffer){
@@ -110,7 +110,7 @@ static const char* decode() {
}
while (true) {
wuffs_base__status z =
status =
wuffs_gzip__decoder__decode(&dec, wuffs_base__io_buffer__writer(&dst),
wuffs_base__io_buffer__reader(&src));
@@ -122,13 +122,13 @@ static const char* decode() {
wuffs_base__io_buffer__compact(&dst);
}
if (z == wuffs_base__suspension__short_read) {
if (status == wuffs_base__suspension__short_read) {
break;
}
if (z == wuffs_base__suspension__short_write) {
if (status == wuffs_base__suspension__short_write) {
continue;
}
return z;
return status;
}
wuffs_base__io_buffer__compact(&src);
+14 -14
View File
@@ -55,17 +55,17 @@ const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) {
// variable initialization" warnings.
{
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_base__status z = wuffs_gif__decoder__check_wuffs_version(
const char* status = wuffs_gif__decoder__check_wuffs_version(
&dec, sizeof dec, WUFFS_VERSION);
if (z) {
ret = z;
if (status) {
ret = status;
goto exit;
}
wuffs_base__image_config ic = ((wuffs_base__image_config){});
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z) {
ret = z;
status = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (status) {
ret = status;
goto exit;
}
if (!wuffs_base__image_config__is_valid(&ic)) {
@@ -96,19 +96,19 @@ const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) {
}
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg, pixbuf);
if (z) {
ret = z;
status = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg, pixbuf);
if (status) {
ret = status;
goto exit;
}
bool seen_ok = false;
while (true) {
z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader, workbuf,
NULL);
if (z) {
if ((z != wuffs_base__warning__end_of_data) || !seen_ok) {
ret = z;
status = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader, workbuf,
NULL);
if (status) {
if ((status != wuffs_base__warning__end_of_data) || !seen_ok) {
ret = status;
}
goto exit;
}
+6 -6
View File
@@ -48,10 +48,10 @@ It should print "PASS", amongst other information, and exit(0).
const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) {
wuffs_zlib__decoder dec = ((wuffs_zlib__decoder){});
wuffs_base__status z =
const char* status =
wuffs_zlib__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
return z;
if (status) {
return status;
}
// Ignore the checksum for 99.99%-ish of all input. When fuzzers generate
@@ -71,8 +71,8 @@ const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) {
while (true) {
dst.meta.wi = 0;
z = wuffs_zlib__decoder__decode(&dec, dst_writer, src_reader);
if (z != wuffs_base__suspension__short_write) {
status = wuffs_zlib__decoder__decode(&dec, dst_writer, src_reader);
if (status != wuffs_base__suspension__short_write) {
break;
}
if (dst.meta.wi == 0) {
@@ -80,5 +80,5 @@ const char* fuzz(wuffs_base__io_reader src_reader, uint32_t hash) {
intentional_segfault();
}
}
return z;
return status;
}
@@ -150,7 +150,7 @@ wuffs_base__status c_wuffs_deflate__decoder__decode_huffman_fast(
if (!a_dst.private_impl.buf || !a_src.private_impl.buf) {
return wuffs_base__error__bad_argument;
}
wuffs_base__status z = NULL;
wuffs_base__status status = NULL;
// Load contextual state. Prepare to check that pdst and psrc remain within
// a_dst's and a_src's bounds.
@@ -236,7 +236,8 @@ outer_loop:
goto end;
}
if ((table_entry >> 24) != 0x10) {
z = wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto end;
}
uint32_t top = (table_entry >> 8) & 0xFFFF;
@@ -282,7 +283,8 @@ outer_loop:
break;
}
if ((table_entry >> 24) != 0x10) {
z = wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
status =
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
goto end;
}
uint32_t top = (table_entry >> 8) & 0xFFFF;
@@ -311,7 +313,7 @@ outer_loop:
// TODO: look at a sliding window, not just output written so far to dst.
if ((ptrdiff_t)(dist_minus_1 + 1) > (pdst - pdst0)) {
z = wuffs_base__error__bad_argument;
status = wuffs_base__error__bad_argument;
goto end;
}
@@ -363,5 +365,5 @@ end:
self->private_impl.f_bits = bits;
self->private_impl.f_n_bits = n_bits;
return z;
return status;
}
+13 -13
View File
@@ -120,18 +120,18 @@ const char* test_wuffs_adler32_golden() {
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
const char* z = read_file(&src, test_cases[i].filename);
if (z) {
return z;
const char* status = read_file(&src, test_cases[i].filename);
if (status) {
return status;
}
int j;
for (j = 0; j < 2; j++) {
wuffs_adler32__hasher checksum = ((wuffs_adler32__hasher){});
z = wuffs_adler32__hasher__check_wuffs_version(&checksum, sizeof checksum,
WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status = wuffs_adler32__hasher__check_wuffs_version(
&checksum, sizeof checksum, WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
uint32_t got = 0;
@@ -190,10 +190,10 @@ const char* test_wuffs_adler32_pi() {
int i;
for (i = 0; i < 64; i++) {
wuffs_adler32__hasher checksum = ((wuffs_adler32__hasher){});
const char* z = wuffs_adler32__hasher__check_wuffs_version(
const char* status = wuffs_adler32__hasher__check_wuffs_version(
&checksum, sizeof checksum, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
uint32_t got =
wuffs_adler32__hasher__update(&checksum, ((wuffs_base__slice_u8){
@@ -221,10 +221,10 @@ const char* wuffs_bench_adler32(wuffs_base__io_buffer* dst,
len = wuffs_base__u64__min(len, rlimit);
}
wuffs_adler32__hasher checksum = ((wuffs_adler32__hasher){});
const char* z = wuffs_adler32__hasher__check_wuffs_version(
const char* status = wuffs_adler32__hasher__check_wuffs_version(
&checksum, sizeof checksum, WUFFS_VERSION);
if (z) {
return z;
if (status) {
return status;
}
global_wuffs_adler32_unused_u32 = wuffs_adler32__hasher__update(
&checksum, ((wuffs_base__slice_u8){
+12 -12
View File
@@ -120,18 +120,18 @@ const char* test_wuffs_crc32_ieee_golden() {
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
const char* z = read_file(&src, test_cases[i].filename);
if (z) {
return z;
const char* status = read_file(&src, test_cases[i].filename);
if (status) {
return status;
}
int j;
for (j = 0; j < 2; j++) {
wuffs_crc32__ieee_hasher checksum = ((wuffs_crc32__ieee_hasher){});
z = wuffs_crc32__ieee_hasher__check_wuffs_version(
status = wuffs_crc32__ieee_hasher__check_wuffs_version(
&checksum, sizeof checksum, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
uint32_t got = 0;
@@ -211,10 +211,10 @@ const char* do_test_xxxxx_crc32_ieee_pi(bool mimic) {
} else {
wuffs_crc32__ieee_hasher checksum = ((wuffs_crc32__ieee_hasher){});
const char* z = wuffs_crc32__ieee_hasher__check_wuffs_version(
const char* status = wuffs_crc32__ieee_hasher__check_wuffs_version(
&checksum, sizeof checksum, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
got = wuffs_crc32__ieee_hasher__update(&checksum, data);
}
@@ -256,10 +256,10 @@ const char* wuffs_bench_crc32_ieee(wuffs_base__io_buffer* dst,
len = wuffs_base__u64__min(len, rlimit);
}
wuffs_crc32__ieee_hasher checksum = ((wuffs_crc32__ieee_hasher){});
const char* z = wuffs_crc32__ieee_hasher__check_wuffs_version(
const char* status = wuffs_crc32__ieee_hasher__check_wuffs_version(
&checksum, sizeof checksum, WUFFS_VERSION);
if (z) {
return z;
if (status) {
return status;
}
global_wuffs_crc32_unused_u32 = wuffs_crc32__ieee_hasher__update(
&checksum, ((wuffs_base__slice_u8){
+58 -58
View File
@@ -131,10 +131,10 @@ const char* wuffs_deflate_decode(wuffs_base__io_buffer* dst,
uint64_t wlimit,
uint64_t rlimit) {
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
const char* z = wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec,
WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
const char* status = wuffs_deflate__decoder__check_wuffs_version(
&dec, sizeof dec, WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
while (true) {
@@ -147,13 +147,13 @@ const char* wuffs_deflate_decode(wuffs_base__io_buffer* dst,
set_reader_limit(&src_reader, rlimit);
}
z = wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader);
status = wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader);
if ((wlimit && (z == wuffs_base__suspension__short_write)) ||
(rlimit && (z == wuffs_base__suspension__short_read))) {
if ((wlimit && (status == wuffs_base__suspension__short_write)) ||
(rlimit && (status == wuffs_base__suspension__short_read))) {
continue;
}
return z;
return status;
}
}
@@ -223,15 +223,15 @@ const char* test_wuffs_deflate_decode_split_src() {
.data = global_want_slice,
});
const char* z;
const char* status;
golden_test* gt = &deflate_256_bytes_gt;
z = read_file(&src, gt->src_filename);
if (z) {
return z;
status = read_file(&src, gt->src_filename);
if (status) {
return status;
}
z = read_file(&want, gt->want_filename);
if (z) {
return z;
status = read_file(&want, gt->want_filename);
if (status) {
return status;
}
wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(&got);
@@ -246,10 +246,10 @@ const char* test_wuffs_deflate_decode_split_src() {
got.meta.wi = 0;
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
z = wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec,
WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status = wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec,
WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
src.meta.closed = false;
@@ -275,9 +275,9 @@ const char* test_wuffs_deflate_decode_split_src() {
char prefix[64];
snprintf(prefix, 64, "i=%d: ", i);
z = check_io_buffers_equal(prefix, &got, &want);
if (z) {
return z;
status = check_io_buffers_equal(prefix, &got, &want);
if (status) {
return status;
}
}
return NULL;
@@ -326,32 +326,32 @@ const char* test_wuffs_deflate_history_full() {
.data = global_want_slice,
});
const char* z;
const char* status;
golden_test* gt = &deflate_pi_gt;
z = read_file(&src, gt->src_filename);
if (z) {
return z;
status = read_file(&src, gt->src_filename);
if (status) {
return status;
}
z = read_file(&want, gt->want_filename);
if (z) {
return z;
status = read_file(&want, gt->want_filename);
if (status) {
return status;
}
const int full_history_size = 0x8000;
int i;
for (i = -2; i <= +2; i++) {
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
z = wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec,
WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status = wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec,
WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
z = do_test_wuffs_deflate_history(
status = do_test_wuffs_deflate_history(
i, gt, &src, &got, &dec, 0, want.meta.wi + i,
i >= 0 ? NULL : wuffs_base__suspension__short_write);
if (z) {
return z;
if (status) {
return status;
}
uint32_t want_history_index = i >= 0 ? 0 : full_history_size;
@@ -381,9 +381,9 @@ const char* test_wuffs_deflate_history_full() {
});
history_want.meta.wi = full_history_size;
z = check_io_buffers_equal("", &history_got, &history_want);
if (z) {
return z;
status = check_io_buffers_equal("", &history_got, &history_want);
if (status) {
return status;
}
}
return NULL;
@@ -400,9 +400,9 @@ const char* test_wuffs_deflate_history_partial() {
});
golden_test* gt = &deflate_pi_gt;
const char* z = read_file(&src, gt->src_filename);
if (z) {
return z;
const char* status = read_file(&src, gt->src_filename);
if (status) {
return status;
}
uint32_t starting_history_indexes[] = {
@@ -419,17 +419,17 @@ const char* test_wuffs_deflate_history_partial() {
const uint32_t fragment_length = 4;
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
z = wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec,
WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status = wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec,
WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
z = do_test_wuffs_deflate_history(i, gt, &src, &got, &dec,
starting_history_index, fragment_length,
wuffs_base__suspension__short_write);
if (z) {
return z;
status = do_test_wuffs_deflate_history(
i, gt, &src, &got, &dec, starting_history_index, fragment_length,
wuffs_base__suspension__short_write);
if (status) {
return status;
}
bool got_full = dec.private_impl.f_history_index >= 0x8000;
@@ -506,10 +506,10 @@ const char* test_wuffs_deflate_table_redirect() {
// 2nd is the key in the second level table (variable bits).
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
const char* z = wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec,
WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
const char* status = wuffs_deflate__decoder__check_wuffs_version(
&dec, sizeof dec, WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
int i;
@@ -529,9 +529,9 @@ const char* test_wuffs_deflate_table_redirect() {
dec.private_impl.f_code_lengths[n++] = 13;
dec.private_impl.f_code_lengths[n++] = 13;
z = wuffs_deflate__decoder__init_huff(&dec, 0, 0, n, 257);
if (z) {
RETURN_FAIL("init_huff: \"%s\"", z);
status = wuffs_deflate__decoder__init_huff(&dec, 0, 0, n, 257);
if (status) {
RETURN_FAIL("init_huff: \"%s\"", status);
}
// There is one 1st-level table (9 bits), and three 2nd-level tables (3, 3
+275 -263
View File
@@ -72,9 +72,9 @@ const char* test_basic_bad_receiver() {
CHECK_FOCUS(__func__);
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src = ((wuffs_base__io_reader){});
const char* z = wuffs_gif__decoder__decode_image_config(NULL, &ic, src);
if (z != wuffs_base__error__bad_receiver) {
RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", z,
const char* status = wuffs_gif__decoder__decode_image_config(NULL, &ic, src);
if (status != wuffs_base__error__bad_receiver) {
RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", status,
wuffs_base__error__bad_receiver);
}
return NULL;
@@ -83,10 +83,10 @@ const char* test_basic_bad_receiver() {
const char* test_basic_bad_sizeof_receiver() {
CHECK_FOCUS(__func__);
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
const char* z =
const char* status =
wuffs_gif__decoder__check_wuffs_version(&dec, 0, WUFFS_VERSION);
if (z != wuffs_base__error__bad_sizeof_receiver) {
RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", z,
if (status != wuffs_base__error__bad_sizeof_receiver) {
RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", status,
wuffs_base__error__bad_sizeof_receiver);
}
return NULL;
@@ -95,10 +95,10 @@ const char* test_basic_bad_sizeof_receiver() {
const char* test_basic_bad_wuffs_version() {
CHECK_FOCUS(__func__);
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
const char* z = wuffs_gif__decoder__check_wuffs_version(
const char* status = wuffs_gif__decoder__check_wuffs_version(
&dec, sizeof dec, WUFFS_VERSION ^ 0x123456789ABC);
if (z != wuffs_base__error__bad_wuffs_version) {
RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", z,
if (status != wuffs_base__error__bad_wuffs_version) {
RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", status,
wuffs_base__error__bad_wuffs_version);
}
return NULL;
@@ -109,9 +109,9 @@ const char* test_basic_check_wuffs_version_not_called() {
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src = ((wuffs_base__io_reader){});
const char* z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src);
if (z != wuffs_base__error__check_wuffs_version_missing) {
RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", z,
const char* status = wuffs_gif__decoder__decode_image_config(&dec, &ic, src);
if (status != wuffs_base__error__check_wuffs_version_missing) {
RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", status,
wuffs_base__error__check_wuffs_version_missing);
}
return NULL;
@@ -169,10 +169,10 @@ const char* test_basic_status_used_package() {
const char* test_basic_sub_struct_initializer() {
CHECK_FOCUS(__func__);
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
const char* z =
const char* status =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
if (dec.private_impl.magic != WUFFS_BASE__MAGIC) {
RETURN_FAIL("outer magic: got %" PRIu32 ", want %" PRIu32 "",
@@ -191,18 +191,18 @@ const char* wuffs_gif_decode(wuffs_base__io_buffer* dst,
wuffs_base__pixel_format pixfmt,
wuffs_base__io_buffer* src) {
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
const char* z =
const char* status =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
return z;
if (status) {
return status;
}
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(src);
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z) {
return z;
status = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (status) {
return status;
}
wuffs_base__pixel_config__initialize(
@@ -211,30 +211,30 @@ const char* wuffs_gif_decode(wuffs_base__io_buffer* dst,
wuffs_base__pixel_config__height(&ic.pixcfg));
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (z) {
return z;
status = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (status) {
return status;
}
while (true) {
z = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader);
if (z == wuffs_base__warning__end_of_data) {
status = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader);
if (status == wuffs_base__warning__end_of_data) {
break;
} else if (z) {
return z;
} else if (status) {
return status;
}
z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader,
global_work_slice, NULL);
if (z) {
return z;
status = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader,
global_work_slice, NULL);
if (status) {
return status;
}
z = copy_to_io_buffer_from_pixel_buffer(
status = copy_to_io_buffer_from_pixel_buffer(
dst, &pb, wuffs_base__frame_config__bounds(&fc));
if (z) {
return z;
if (status) {
return status;
}
}
return NULL;
@@ -252,15 +252,16 @@ const char* do_test_wuffs_gif_decode(const char* filename,
.data = global_src_slice,
});
const char* z = read_file(&src, filename);
if (z) {
return z;
const char* status = read_file(&src, filename);
if (status) {
return status;
}
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
@@ -269,9 +270,9 @@ const char* do_test_wuffs_gif_decode(const char* filename,
{
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z) {
RETURN_FAIL("decode_image_config: got \"%s\"", z);
status = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (status) {
RETURN_FAIL("decode_image_config: got \"%s\"", status);
}
if (wuffs_base__pixel_config__pixel_format(&ic.pixcfg) !=
WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY) {
@@ -296,10 +297,10 @@ const char* do_test_wuffs_gif_decode(const char* filename,
wuffs_base__pixel_config__initialize(
&ic.pixcfg, dst_pixfmt, WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, 160, 120);
z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (z) {
RETURN_FAIL("set_from_slice: \"%s\"", z);
status = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (status) {
RETURN_FAIL("set_from_slice: \"%s\"", status);
}
uint32_t got = wuffs_gif__decoder__num_animation_loops(&dec);
@@ -322,13 +323,13 @@ const char* do_test_wuffs_gif_decode(const char* filename,
}
size_t old_ri = src.meta.ri;
z = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader);
status = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader);
if (!z) {
if (!status) {
break;
}
if (z != wuffs_base__suspension__short_read) {
RETURN_FAIL("decode_frame_config: got \"%s\", want \"%s\"", z,
if (status != wuffs_base__suspension__short_read) {
RETURN_FAIL("decode_frame_config: got \"%s\", want \"%s\"", status,
wuffs_base__suspension__short_read);
}
@@ -348,14 +349,14 @@ const char* do_test_wuffs_gif_decode(const char* filename,
}
size_t old_ri = src.meta.ri;
const char* z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader,
global_work_slice, NULL);
const char* status = wuffs_gif__decoder__decode_frame(
&dec, &pb, src_reader, global_work_slice, NULL);
if (!z) {
if (!status) {
break;
}
if (z != wuffs_base__suspension__short_read) {
RETURN_FAIL("decode_frame: got \"%s\", want \"%s\"", z,
if (status != wuffs_base__suspension__short_read) {
RETURN_FAIL("decode_frame: got \"%s\", want \"%s\"", status,
wuffs_base__suspension__short_read);
}
@@ -367,10 +368,10 @@ const char* do_test_wuffs_gif_decode(const char* filename,
}
}
z = copy_to_io_buffer_from_pixel_buffer(
status = copy_to_io_buffer_from_pixel_buffer(
&got, &pb, wuffs_base__frame_config__bounds(&fc));
if (z) {
return z;
if (status) {
return status;
}
if (rlimit) {
@@ -390,32 +391,32 @@ const char* do_test_wuffs_gif_decode(const char* filename,
.len = 1024,
}),
});
z = read_file(&pal_want, palette_filename);
if (z) {
return z;
status = read_file(&pal_want, palette_filename);
if (status) {
return status;
}
if (dst_pixfmt == WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY) {
wuffs_base__io_buffer pal_got = ((wuffs_base__io_buffer){
.data = wuffs_base__pixel_buffer__palette(&pb),
});
pal_got.meta.wi = pal_got.data.len;
z = check_io_buffers_equal("palette ", &pal_got, &pal_want);
if (z) {
return z;
status = check_io_buffers_equal("palette ", &pal_got, &pal_want);
if (status) {
return status;
}
}
wuffs_base__io_buffer ind_want = ((wuffs_base__io_buffer){
.data = global_want_slice,
});
z = read_file(&ind_want, indexes_filename);
if (z) {
return z;
status = read_file(&ind_want, indexes_filename);
if (status) {
return status;
}
if (dst_pixfmt == WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY) {
z = check_io_buffers_equal("indexes ", &got, &ind_want);
if (z) {
return z;
status = check_io_buffers_equal("indexes ", &got, &ind_want);
if (status) {
return status;
}
} else {
wuffs_base__io_buffer expanded_want = ((wuffs_base__io_buffer){
@@ -433,9 +434,9 @@ const char* do_test_wuffs_gif_decode(const char* filename,
expanded_want.data.ptr[4 * i + 3] = pal_want_array[4 * index + 3];
}
expanded_want.meta.wi = 4 * ind_want.meta.wi;
z = check_io_buffers_equal("pixels ", &got, &expanded_want);
if (z) {
return z;
status = check_io_buffers_equal("pixels ", &got, &expanded_want);
if (status) {
return status;
}
}
@@ -444,10 +445,10 @@ const char* do_test_wuffs_gif_decode(const char* filename,
RETURN_FAIL("decode_frame returned \"ok\" but src was exhausted");
}
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader,
global_work_slice, NULL);
if (z != wuffs_base__warning__end_of_data) {
RETURN_FAIL("decode_frame: got \"%s\", want \"%s\"", z,
status = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader,
global_work_slice, NULL);
if (status != wuffs_base__warning__end_of_data) {
RETURN_FAIL("decode_frame: got \"%s\", want \"%s\"", status,
wuffs_base__warning__end_of_data);
}
if (src.meta.ri != src.meta.wi) {
@@ -466,27 +467,28 @@ const char* test_wuffs_gif_call_sequence() {
.data = global_src_slice,
});
const char* z = read_file(&src, "test/data/bricks-dither.gif");
if (z) {
return z;
const char* status = read_file(&src, "test/data/bricks-dither.gif");
if (status) {
return status;
}
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
z = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader);
if (z) {
RETURN_FAIL("decode_image_config: got \"%s\"", z);
status = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader);
if (status) {
RETURN_FAIL("decode_image_config: got \"%s\"", status);
}
z = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader);
if (z != wuffs_base__error__bad_call_sequence) {
RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", z,
status = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader);
if (status != wuffs_base__error__bad_call_sequence) {
RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", status,
wuffs_base__error__bad_call_sequence);
}
return NULL;
@@ -501,23 +503,24 @@ const char* do_test_wuffs_gif_decode_animated(
.data = global_src_slice,
});
const char* z = read_file(&src, filename);
if (z) {
return z;
const char* status = read_file(&src, filename);
if (status) {
return status;
}
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z) {
RETURN_FAIL("decode_image_config: got \"%s\"", z);
status = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (status) {
RETURN_FAIL("decode_image_config: got \"%s\"", status);
}
uint32_t got_num_loops = wuffs_gif__decoder__num_animation_loops(&dec);
@@ -527,18 +530,18 @@ const char* do_test_wuffs_gif_decode_animated(
}
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (z) {
RETURN_FAIL("set_from_slice: \"%s\"", z);
status = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (status) {
RETURN_FAIL("set_from_slice: \"%s\"", status);
}
uint32_t i;
for (i = 0; i < want_num_frames; i++) {
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
z = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader);
if (z) {
RETURN_FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i, z);
status = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader);
if (status) {
RETURN_FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i, status);
}
if (want_frame_config_bounds) {
@@ -554,20 +557,20 @@ const char* do_test_wuffs_gif_decode_animated(
}
}
z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader,
global_work_slice, NULL);
if (z) {
RETURN_FAIL("decode_frame #%" PRIu32 ": got \"%s\"", i, z);
status = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader,
global_work_slice, NULL);
if (status) {
RETURN_FAIL("decode_frame #%" PRIu32 ": got \"%s\"", i, status);
}
}
// There should be no more frames, no matter how many times we call
// decode_frame.
for (i = 0; i < 3; i++) {
z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader,
global_work_slice, NULL);
if (z != wuffs_base__warning__end_of_data) {
RETURN_FAIL("decode_frame: got \"%s\", want \"%s\"", z,
status = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader,
global_work_slice, NULL);
if (status != wuffs_base__warning__end_of_data) {
RETURN_FAIL("decode_frame: got \"%s\", want \"%s\"", status,
wuffs_base__warning__end_of_data);
}
}
@@ -616,22 +619,23 @@ const char* test_wuffs_gif_decode_frame_out_of_bounds() {
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
const char* z =
const char* status =
read_file(&src, "test/data/artificial/gif-frame-out-of-bounds.gif");
if (z) {
return z;
if (status) {
return status;
}
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z) {
RETURN_FAIL("decode_image_config: \"%s\"", z);
status = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (status) {
RETURN_FAIL("decode_image_config: \"%s\"", status);
}
// The nominal width and height for the overall image is 2×2, but its first
@@ -652,10 +656,10 @@ const char* test_wuffs_gif_decode_frame_out_of_bounds() {
}
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (z) {
RETURN_FAIL("set_from_slice: \"%s\"", z);
status = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (status) {
RETURN_FAIL("set_from_slice: \"%s\"", status);
}
// See test/data/artificial/gif-frame-out-of-bounds.gif.make-artificial.txt
@@ -679,15 +683,16 @@ const char* test_wuffs_gif_decode_frame_out_of_bounds() {
for (i = 0; true; i++) {
{
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
z = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader);
status = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader);
if (i == WUFFS_TESTLIB_ARRAY_SIZE(want_frame_config_bounds)) {
if (z != wuffs_base__warning__end_of_data) {
RETURN_FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i, z);
if (status != wuffs_base__warning__end_of_data) {
RETURN_FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i,
status);
}
break;
}
if (z) {
RETURN_FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i, z);
if (status) {
RETURN_FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i, status);
}
wuffs_base__rect_ie_u32 got = wuffs_base__frame_config__bounds(&fc);
@@ -711,10 +716,10 @@ const char* test_wuffs_gif_decode_frame_out_of_bounds() {
}
}
z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader,
global_work_slice, NULL);
if (z) {
RETURN_FAIL("decode_frame #%" PRIu32 ": got \"%s\"", i, z);
status = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader,
global_work_slice, NULL);
if (status) {
RETURN_FAIL("decode_frame #%" PRIu32 ": got \"%s\"", i, status);
}
char got[(width * height) + 1];
@@ -787,22 +792,23 @@ const char* test_wuffs_gif_decode_input_is_a_png() {
.data = global_src_slice,
});
const char* z = read_file(&src, "test/data/bricks-dither.png");
if (z) {
return z;
const char* status = read_file(&src, "test/data/bricks-dither.png");
if (status) {
return status;
}
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z != wuffs_gif__error__bad_header) {
RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", z,
status = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (status != wuffs_gif__error__bad_header) {
RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", status,
wuffs_gif__error__bad_header);
}
return NULL;
@@ -815,9 +821,9 @@ const char* test_wuffs_gif_decode_missing_two_src_bytes() {
.data = global_src_slice,
});
const char* z = read_file(&src, "test/data/pjw-thumbnail.gif");
if (z) {
return z;
const char* status = read_file(&src, "test/data/pjw-thumbnail.gif");
if (status) {
return status;
}
// Trim the final two bytes: the 0x00 end-of-block and the 0x3B trailer.
@@ -827,30 +833,31 @@ const char* test_wuffs_gif_decode_missing_two_src_bytes() {
src.meta.wi -= 2;
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z) {
RETURN_FAIL("decode_image_config: got \"%s\"", z);
status = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (status) {
RETURN_FAIL("decode_image_config: got \"%s\"", status);
}
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (z) {
RETURN_FAIL("set_from_slice: \"%s\"", z);
status = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (status) {
RETURN_FAIL("set_from_slice: \"%s\"", status);
}
z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader, global_work_slice,
NULL);
if (z != wuffs_base__suspension__short_read) {
RETURN_FAIL("decode_frame: got \"%s\"", z);
status = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader,
global_work_slice, NULL);
if (status != wuffs_base__suspension__short_read) {
RETURN_FAIL("decode_frame: got \"%s\"", status);
}
// Even we though we haven't seen the 0x00 end-of-block, we should still have
@@ -867,22 +874,23 @@ const char* test_wuffs_gif_decode_multiple_loop_counts() {
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
const char* z =
const char* status =
read_file(&src, "test/data/artificial/gif-multiple-loop-counts.gif");
if (z) {
return z;
if (status) {
return status;
}
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z) {
RETURN_FAIL("decode_image_config: \"%s\"", z);
status = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (status) {
RETURN_FAIL("decode_image_config: \"%s\"", status);
}
// See test/data/artificial/gif-multiple-loop-counts.gif.make-artificial.txt
@@ -895,15 +903,16 @@ const char* test_wuffs_gif_decode_multiple_loop_counts() {
uint32_t i;
for (i = 0; true; i++) {
{
z = wuffs_gif__decoder__decode_frame_config(&dec, NULL, src_reader);
status = wuffs_gif__decoder__decode_frame_config(&dec, NULL, src_reader);
if (i == WUFFS_TESTLIB_ARRAY_SIZE(want_num_animation_loops)) {
if (z != wuffs_base__warning__end_of_data) {
RETURN_FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i, z);
if (status != wuffs_base__warning__end_of_data) {
RETURN_FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i,
status);
}
break;
}
if (z) {
RETURN_FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i, z);
if (status) {
RETURN_FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i, status);
}
}
@@ -933,29 +942,30 @@ const char* test_wuffs_gif_frame_dirty_rect() {
.data = global_src_slice,
});
const char* z = read_file(&src, "test/data/hippopotamus.interlaced.gif");
if (z) {
return z;
const char* status = read_file(&src, "test/data/hippopotamus.interlaced.gif");
if (status) {
return status;
}
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
wuffs_base__image_config ic = ((wuffs_base__image_config){});
z = wuffs_gif__decoder__decode_image_config(
status = wuffs_gif__decoder__decode_image_config(
&dec, &ic, wuffs_base__io_buffer__reader(&src));
if (z) {
RETURN_FAIL("decode_image_config: \"%s\"", z);
if (status) {
RETURN_FAIL("decode_image_config: \"%s\"", status);
}
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (z) {
RETURN_FAIL("set_from_slice: \"%s\"", z);
status = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (status) {
RETURN_FAIL("set_from_slice: \"%s\"", status);
}
// The hippopotamus.interlaced.gif image is 28 pixels high. As we decode rows
@@ -969,18 +979,18 @@ const char* test_wuffs_gif_frame_dirty_rect() {
while (true) {
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
set_reader_limit(&src_reader, 1);
z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader,
global_work_slice, NULL);
status = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader,
global_work_slice, NULL);
wuffs_base__rect_ie_u32 r = wuffs_gif__decoder__frame_dirty_rect(&dec);
if ((i < WUFFS_TESTLIB_ARRAY_SIZE(wants)) && (wants[i] == r.max_excl_y)) {
i++;
}
if (!z) {
if (!status) {
break;
} else if (z != wuffs_base__suspension__short_read) {
RETURN_FAIL("decode_frame: \"%s\"", z);
} else if (status != wuffs_base__suspension__short_read) {
RETURN_FAIL("decode_frame: \"%s\"", status);
}
}
@@ -996,30 +1006,31 @@ const char* do_test_wuffs_gif_num_decoded(bool frame_config) {
.data = global_src_slice,
});
const char* z = read_file(&src, "test/data/animated-red-blue.gif");
if (z) {
return z;
const char* status = read_file(&src, "test/data/animated-red-blue.gif");
if (status) {
return status;
}
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
if (!frame_config) {
wuffs_base__image_config ic = ((wuffs_base__image_config){});
z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (z) {
RETURN_FAIL("decode_image_config: \"%s\"", z);
status = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader);
if (status) {
RETURN_FAIL("decode_image_config: \"%s\"", status);
}
z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (z) {
RETURN_FAIL("set_from_slice: \"%s\"", z);
status = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (status) {
RETURN_FAIL("set_from_slice: \"%s\"", status);
}
}
@@ -1039,20 +1050,20 @@ const char* do_test_wuffs_gif_num_decoded(bool frame_config) {
break;
}
const char* z = NULL;
const char* status = NULL;
if (frame_config) {
z = wuffs_gif__decoder__decode_frame_config(&dec, NULL, src_reader);
status = wuffs_gif__decoder__decode_frame_config(&dec, NULL, src_reader);
} else {
z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader,
global_work_slice, NULL);
status = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader,
global_work_slice, NULL);
}
if (!z) {
if (!status) {
want++;
} else if (z == wuffs_base__warning__end_of_data) {
} else if (status == wuffs_base__warning__end_of_data) {
end_of_data = true;
} else {
RETURN_FAIL("%s: \"%s\"", method, z);
RETURN_FAIL("%s: \"%s\"", method, status);
}
}
@@ -1076,15 +1087,16 @@ const char* do_test_wuffs_gif_io_position(bool chunked) {
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
const char* z = read_file(&src, "test/data/animated-red-blue.gif");
if (z) {
return z;
const char* status = read_file(&src, "test/data/animated-red-blue.gif");
if (status) {
return status;
}
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status =
wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
@@ -1098,9 +1110,9 @@ const char* do_test_wuffs_gif_io_position(bool chunked) {
src.meta.wi = 30;
src.meta.closed = false;
z = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader);
if (z != wuffs_base__suspension__short_read) {
RETURN_FAIL("decode_image_config (chunked): \"%s\"", z);
status = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader);
if (status != wuffs_base__suspension__short_read) {
RETURN_FAIL("decode_image_config (chunked): \"%s\"", status);
}
src.meta.wi = saved_wi;
@@ -1115,9 +1127,9 @@ const char* do_test_wuffs_gif_io_position(bool chunked) {
}
}
z = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader);
if (z) {
RETURN_FAIL("decode_image_config: \"%s\"", z);
status = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader);
if (status) {
RETURN_FAIL("decode_image_config: \"%s\"", status);
}
wuffs_base__frame_config fcs[4];
@@ -1126,9 +1138,9 @@ const char* do_test_wuffs_gif_io_position(bool chunked) {
int i;
for (i = 0; i < 4; i++) {
fcs[i] = ((wuffs_base__frame_config){});
z = wuffs_gif__decoder__decode_frame_config(&dec, &fcs[i], src_reader);
if (z) {
RETURN_FAIL("decode_frame_config #%d: \"%s\"", i, z);
status = wuffs_gif__decoder__decode_frame_config(&dec, &fcs[i], src_reader);
if (status) {
RETURN_FAIL("decode_frame_config #%d: \"%s\"", i, status);
}
uint64_t index_got = wuffs_base__frame_config__index(&fcs[i]);
@@ -1171,9 +1183,9 @@ const char* do_test_wuffs_gif_io_position(bool chunked) {
}
}
z = wuffs_gif__decoder__decode_frame_config(&dec, NULL, src_reader);
if (z != wuffs_base__warning__end_of_data) {
RETURN_FAIL("decode_frame_config EOD: \"%s\"", z);
status = wuffs_gif__decoder__decode_frame_config(&dec, NULL, src_reader);
if (status != wuffs_base__warning__end_of_data) {
RETURN_FAIL("decode_frame_config EOD: \"%s\"", status);
}
// If we're chunked, we've discarded some source bytes due to an earlier
@@ -1186,18 +1198,18 @@ const char* do_test_wuffs_gif_io_position(bool chunked) {
for (i = 0; i < 4; i++) {
src.meta.ri = pos_wants[i];
z = wuffs_gif__decoder__restart_frame(
status = wuffs_gif__decoder__restart_frame(
&dec, i, wuffs_base__frame_config__io_position(&fcs[i]));
if (z) {
RETURN_FAIL("restart_frame #%d: \"%s\"", i, z);
if (status) {
RETURN_FAIL("restart_frame #%d: \"%s\"", i, status);
}
int j;
for (j = i; j < 4; j++) {
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
z = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader);
if (z) {
RETURN_FAIL("decode_frame_config #%d, #%d: \"%s\"", i, j, z);
status = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader);
if (status) {
RETURN_FAIL("decode_frame_config #%d, #%d: \"%s\"", i, j, status);
}
uint64_t index_got = wuffs_base__frame_config__index(&fc);
@@ -1215,9 +1227,9 @@ const char* do_test_wuffs_gif_io_position(bool chunked) {
}
}
z = wuffs_gif__decoder__decode_frame_config(&dec, NULL, src_reader);
if (z != wuffs_base__warning__end_of_data) {
RETURN_FAIL("decode_frame_config EOD #%d: \"%s\"", i, z);
status = wuffs_gif__decoder__decode_frame_config(&dec, NULL, src_reader);
if (status != wuffs_base__warning__end_of_data) {
RETURN_FAIL("decode_frame_config EOD #%d: \"%s\"", i, status);
}
}
@@ -1242,34 +1254,34 @@ const char* do_test_mimic_gif_decode(const char* filename) {
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
const char* z = read_file(&src, filename);
if (z) {
return z;
const char* status = read_file(&src, filename);
if (status) {
return status;
}
src.meta.ri = 0;
wuffs_base__io_buffer got = ((wuffs_base__io_buffer){
.data = global_got_slice,
});
z = wuffs_gif_decode(&got, WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY,
&src);
if (z) {
return z;
status = wuffs_gif_decode(
&got, WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY, &src);
if (status) {
return status;
}
src.meta.ri = 0;
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
.data = global_want_slice,
});
z = mimic_gif_decode(&want, WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY,
&src);
if (z) {
return z;
status = mimic_gif_decode(
&want, WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY, &src);
if (status) {
return status;
}
z = check_io_buffers_equal("", &got, &want);
if (z) {
return z;
status = check_io_buffers_equal("", &got, &want);
if (status) {
return status;
}
// TODO: check the palette RGB values, not just the palette indexes
@@ -1361,9 +1373,9 @@ const char* do_bench_gif_decode(
.data = global_src_slice,
});
const char* z = read_file(&src, filename);
if (z) {
return z;
const char* status = read_file(&src, filename);
if (status) {
return status;
}
bench_start();
@@ -1373,9 +1385,9 @@ const char* do_bench_gif_decode(
for (i = 0; i < iters; i++) {
got.meta.wi = 0;
src.meta.ri = 0;
z = decode_func(&got, pixfmt, &src);
if (z) {
return z;
status = decode_func(&got, pixfmt, &src);
if (status) {
return status;
}
n_bytes += got.meta.wi;
}
+14 -14
View File
@@ -86,10 +86,10 @@ const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst,
uint64_t wlimit,
uint64_t rlimit) {
wuffs_gzip__decoder dec = ((wuffs_gzip__decoder){});
const char* z =
const char* status =
wuffs_gzip__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
return z;
if (status) {
return status;
}
while (true) {
@@ -102,13 +102,13 @@ const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst,
set_reader_limit(&src_reader, rlimit);
}
z = wuffs_gzip__decoder__decode(&dec, dst_writer, src_reader);
status = wuffs_gzip__decoder__decode(&dec, dst_writer, src_reader);
if ((wlimit && (z == wuffs_base__suspension__short_write)) ||
(rlimit && (z == wuffs_base__suspension__short_read))) {
if ((wlimit && (status == wuffs_base__suspension__short_write)) ||
(rlimit && (status == wuffs_base__suspension__short_read))) {
continue;
}
return z;
return status;
}
}
@@ -121,9 +121,9 @@ const char* do_test_wuffs_gzip_checksum(bool ignore_checksum,
.data = global_src_slice,
});
const char* z = read_file(&src, gzip_midsummer_gt.src_filename);
if (z) {
return z;
const char* status = read_file(&src, gzip_midsummer_gt.src_filename);
if (status) {
return status;
}
// Flip a bit in the gzip checksum, which is in the last 8 bytes of the file.
@@ -137,10 +137,10 @@ const char* do_test_wuffs_gzip_checksum(bool ignore_checksum,
int end_limit;
for (end_limit = 0; end_limit < 10; end_limit++) {
wuffs_gzip__decoder dec = ((wuffs_gzip__decoder){});
z = wuffs_gzip__decoder__check_wuffs_version(&dec, sizeof dec,
WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status = wuffs_gzip__decoder__check_wuffs_version(&dec, sizeof dec,
WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
wuffs_gzip__decoder__set_ignore_checksum(&dec, ignore_checksum);
got.meta.wi = 0;
+39 -38
View File
@@ -80,9 +80,9 @@ const char* do_test_wuffs_lzw_decode(const char* src_filename,
.data = global_src_slice,
});
const char* z = read_file(&src, src_filename);
if (z) {
return z;
const char* status = read_file(&src, src_filename);
if (status) {
return status;
}
if (src.meta.wi != src_size) {
RETURN_FAIL("src size: got %d, want %d", (int)(src.meta.wi),
@@ -96,9 +96,9 @@ const char* do_test_wuffs_lzw_decode(const char* src_filename,
}
src.meta.ri++;
z = read_file(&want, want_filename);
if (z) {
return z;
status = read_file(&want, want_filename);
if (status) {
return status;
}
if (want.meta.wi != want_size) {
RETURN_FAIL("want size: got %d, want %d", (int)(want.meta.wi),
@@ -106,9 +106,10 @@ const char* do_test_wuffs_lzw_decode(const char* src_filename,
}
wuffs_lzw__decoder dec = ((wuffs_lzw__decoder){});
z = wuffs_lzw__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status =
wuffs_lzw__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
wuffs_lzw__decoder__set_literal_width(&dec, literal_width);
int num_iters = 0;
@@ -125,16 +126,16 @@ const char* do_test_wuffs_lzw_decode(const char* src_filename,
size_t old_wi = got.meta.wi;
size_t old_ri = src.meta.ri;
z = wuffs_lzw__decoder__decode(&dec, got_writer, src_reader);
if (!z) {
status = wuffs_lzw__decoder__decode(&dec, got_writer, src_reader);
if (!status) {
if (src.meta.ri != src.meta.wi) {
RETURN_FAIL("decode returned \"ok\" but src was not exhausted");
}
break;
}
if ((z != wuffs_base__suspension__short_read) &&
(z != wuffs_base__suspension__short_write)) {
RETURN_FAIL("decode: got \"%s\", want \"%s\" or \"%s\"", z,
if ((status != wuffs_base__suspension__short_read) &&
(status != wuffs_base__suspension__short_write)) {
RETURN_FAIL("decode: got \"%s\", want \"%s\" or \"%s\"", status,
wuffs_base__suspension__short_read,
wuffs_base__suspension__short_write);
}
@@ -221,17 +222,17 @@ const char* test_wuffs_lzw_decode_output_bad() {
src.data.ptr[3] = 0xFF;
wuffs_lzw__decoder dec = ((wuffs_lzw__decoder){});
const char* z =
const char* status =
wuffs_lzw__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
wuffs_lzw__decoder__set_literal_width(&dec, 7);
z = wuffs_lzw__decoder__decode(&dec, wuffs_base__io_buffer__writer(&got),
wuffs_base__io_buffer__reader(&src));
if (z != wuffs_lzw__error__bad_code) {
RETURN_FAIL("decode: \"%s\"", z);
status = wuffs_lzw__decoder__decode(&dec, wuffs_base__io_buffer__writer(&got),
wuffs_base__io_buffer__reader(&src));
if (status != wuffs_lzw__error__bad_code) {
RETURN_FAIL("decode: \"%s\"", status);
}
if (got.meta.wi != 3) {
@@ -264,17 +265,17 @@ const char* test_wuffs_lzw_decode_output_empty() {
src.data.ptr[1] = 0x01;
wuffs_lzw__decoder dec = ((wuffs_lzw__decoder){});
const char* z =
const char* status =
wuffs_lzw__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
wuffs_lzw__decoder__set_literal_width(&dec, 8);
z = wuffs_lzw__decoder__decode(&dec, wuffs_base__io_buffer__writer(&got),
wuffs_base__io_buffer__reader(&src));
if (z) {
RETURN_FAIL("decode: \"%s\"", z);
status = wuffs_lzw__decoder__decode(&dec, wuffs_base__io_buffer__writer(&got),
wuffs_base__io_buffer__reader(&src));
if (status) {
RETURN_FAIL("decode: \"%s\"", status);
}
if (got.meta.wi != 0) {
@@ -299,9 +300,9 @@ const char* do_bench_wuffs_lzw_decode(const char* filename,
wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got);
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
const char* z = read_file(&src, filename);
if (z) {
return z;
const char* status = read_file(&src, filename);
if (status) {
return status;
}
if (src.meta.wi <= 0) {
RETURN_FAIL("src size: got %d, want > 0", (int)(src.meta.wi));
@@ -320,14 +321,14 @@ const char* do_bench_wuffs_lzw_decode(const char* filename,
got.meta.wi = 0;
src.meta.ri = 1; // Skip the literal width.
wuffs_lzw__decoder dec = ((wuffs_lzw__decoder){});
z = wuffs_lzw__decoder__check_wuffs_version(&dec, sizeof dec,
WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status = wuffs_lzw__decoder__check_wuffs_version(&dec, sizeof dec,
WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
z = wuffs_lzw__decoder__decode(&dec, got_writer, src_reader);
if (z) {
RETURN_FAIL("decode: \"%s\"", z);
status = wuffs_lzw__decoder__decode(&dec, got_writer, src_reader);
if (status) {
RETURN_FAIL("decode: \"%s\"", status);
}
n_bytes += got.meta.wi;
}
+14 -14
View File
@@ -86,10 +86,10 @@ const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst,
uint64_t wlimit,
uint64_t rlimit) {
wuffs_zlib__decoder dec = ((wuffs_zlib__decoder){});
const char* z =
const char* status =
wuffs_zlib__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION);
if (z) {
return z;
if (status) {
return status;
}
while (true) {
@@ -102,13 +102,13 @@ const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst,
set_reader_limit(&src_reader, rlimit);
}
z = wuffs_zlib__decoder__decode(&dec, dst_writer, src_reader);
status = wuffs_zlib__decoder__decode(&dec, dst_writer, src_reader);
if ((wlimit && (z == wuffs_base__suspension__short_write)) ||
(rlimit && (z == wuffs_base__suspension__short_read))) {
if ((wlimit && (status == wuffs_base__suspension__short_write)) ||
(rlimit && (status == wuffs_base__suspension__short_read))) {
continue;
}
return z;
return status;
}
}
@@ -121,9 +121,9 @@ const char* do_test_wuffs_zlib_checksum(bool ignore_checksum,
.data = global_src_slice,
});
const char* z = read_file(&src, zlib_midsummer_gt.src_filename);
if (z) {
return z;
const char* status = read_file(&src, zlib_midsummer_gt.src_filename);
if (status) {
return status;
}
// Flip a bit in the zlib checksum, which is in the last 4 bytes of the file.
if (src.meta.wi < 4) {
@@ -136,10 +136,10 @@ const char* do_test_wuffs_zlib_checksum(bool ignore_checksum,
int end_limit;
for (end_limit = 0; end_limit < 10; end_limit++) {
wuffs_zlib__decoder dec = ((wuffs_zlib__decoder){});
z = wuffs_zlib__decoder__check_wuffs_version(&dec, sizeof dec,
WUFFS_VERSION);
if (z) {
RETURN_FAIL("check_wuffs_version: \"%s\"", z);
status = wuffs_zlib__decoder__check_wuffs_version(&dec, sizeof dec,
WUFFS_VERSION);
if (status) {
RETURN_FAIL("check_wuffs_version: \"%s\"", status);
}
wuffs_zlib__decoder__set_ignore_checksum(&dec, ignore_checksum);
got.meta.wi = 0;
+15 -15
View File
@@ -238,9 +238,9 @@ const char* chdir_to_the_wuffs_root_directory() {
typedef const char* (*proc)();
int test_main(int argc, char** argv, proc* tests, proc* benches) {
const char* z = chdir_to_the_wuffs_root_directory();
if (z) {
fprintf(stderr, "%s\n", z);
const char* status = chdir_to_the_wuffs_root_directory();
if (status) {
fprintf(stderr, "%s\n", status);
return 1;
}
@@ -321,13 +321,13 @@ int test_main(int argc, char** argv, proc* tests, proc* benches) {
proc_func_name = "unknown_func_name";
fail_msg[0] = 0;
in_focus = false;
const char* z = (*p)();
const char* status = (*p)();
if (!in_focus) {
continue;
}
if (z) {
if (status) {
printf("%-16s%-8sFAIL %s: %s\n", proc_package_name, cc, proc_func_name,
z);
status);
return 1;
}
if (i == 0) {
@@ -620,9 +620,9 @@ const char* proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
if (!gt->src_filename) {
src.meta.closed = true;
} else {
const char* z = read_file(&src, gt->src_filename);
if (z) {
return z;
const char* status = read_file(&src, gt->src_filename);
if (status) {
return status;
}
}
if (gt->src_offset0 || gt->src_offset1) {
@@ -644,9 +644,9 @@ const char* proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
for (i = 0; i < iters; i++) {
got.meta.wi = 0;
src.meta.ri = gt->src_offset0;
const char* z = codec_func(&got, &src, wlimit, rlimit);
if (z) {
return z;
const char* status = codec_func(&got, &src, wlimit, rlimit);
if (status) {
return status;
}
switch (tc) {
case tc_neither:
@@ -667,9 +667,9 @@ const char* proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
if (!gt->want_filename) {
want.meta.closed = true;
} else {
const char* z = read_file(&want, gt->want_filename);
if (z) {
return z;
const char* status = read_file(&want, gt->want_filename);
if (status) {
return status;
}
}
return check_io_buffers_equal("", &got, &want);