From 6cc954d7e1d8aa1cbc2c597d660e2ee7665d8dc3 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sat, 22 Sep 2018 08:43:56 +1000 Subject: [PATCH] Have tests return a "const char*" status --- test/c/std/adler32.c | 62 ++-- test/c/std/crc32.c | 60 ++-- test/c/std/deflate.c | 308 +++++++++-------- test/c/std/gif.c | 726 ++++++++++++++++++--------------------- test/c/std/gzip.c | 86 ++--- test/c/std/lzw.c | 136 ++++---- test/c/std/zlib.c | 88 ++--- test/c/testlib/testlib.c | 144 ++++---- 8 files changed, 771 insertions(+), 839 deletions(-) diff --git a/test/c/std/adler32.c b/test/c/std/adler32.c index be47b6cc..ff9eccf8 100644 --- a/test/c/std/adler32.c +++ b/test/c/std/adler32.c @@ -77,7 +77,7 @@ golden_test adler32_pi_gt = { // ---------------- Adler32 Tests -void test_wuffs_adler32_golden() { +const char* test_wuffs_adler32_golden() { CHECK_FOCUS(__func__); struct { @@ -120,18 +120,18 @@ void test_wuffs_adler32_golden() { wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ .data = global_src_slice, }); - if (!read_file(&src, test_cases[i].filename)) { - return; + const char* z = read_file(&src, test_cases[i].filename); + if (z) { + return z; } int j; for (j = 0; j < 2; j++) { wuffs_adler32__hasher checksum = ((wuffs_adler32__hasher){}); - wuffs_base__status z = wuffs_adler32__hasher__check_wuffs_version( - &checksum, sizeof checksum, WUFFS_VERSION); + z = wuffs_adler32__hasher__check_wuffs_version(&checksum, sizeof checksum, + WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } uint32_t got = 0; @@ -152,23 +152,22 @@ void test_wuffs_adler32_golden() { } while (num_bytes < src.meta.wi); if (got != test_cases[i].want) { - FAIL("i=%d, j=%d, filename=\"%s\": got 0x%08" PRIX32 - ", want 0x%08" PRIX32 "\n", - i, j, test_cases[i].filename, got, test_cases[i].want); - return; + RETURN_FAIL("i=%d, j=%d, filename=\"%s\": got 0x%08" PRIX32 + ", want 0x%08" PRIX32 "\n", + i, j, test_cases[i].filename, got, test_cases[i].want); } } } + return NULL; } -void test_wuffs_adler32_pi() { +const char* test_wuffs_adler32_pi() { CHECK_FOCUS(__func__); const char* digits = "3.1415926535897932384626433832795028841971693993751058209749445"; if (strlen(digits) != 63) { - FAIL("strlen(digits): got %d, want 63", (int)(strlen(digits))); - return; + RETURN_FAIL("strlen(digits): got %d, want 63", (int)(strlen(digits))); } // The want values are determined by script/checksum.go. @@ -191,11 +190,10 @@ void test_wuffs_adler32_pi() { int i; for (i = 0; i < 64; i++) { wuffs_adler32__hasher checksum = ((wuffs_adler32__hasher){}); - wuffs_base__status z = wuffs_adler32__hasher__check_wuffs_version( + const char* z = wuffs_adler32__hasher__check_wuffs_version( &checksum, sizeof checksum, WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } uint32_t got = wuffs_adler32__hasher__update(&checksum, ((wuffs_base__slice_u8){ @@ -203,11 +201,11 @@ void test_wuffs_adler32_pi() { .len = i, })); if (got != wants[i]) { - FAIL("i=%d: got 0x%08" PRIX32 ", want 0x%08" PRIX32 "\n", i, got, - wants[i]); - return; + RETURN_FAIL("i=%d: got 0x%08" PRIX32 ", want 0x%08" PRIX32, i, got, + wants[i]); } } + return NULL; } // ---------------- Adler32 Benches @@ -223,7 +221,7 @@ const char* wuffs_bench_adler32(wuffs_base__io_buffer* dst, len = wuffs_base__u64__min(len, rlimit); } wuffs_adler32__hasher checksum = ((wuffs_adler32__hasher){}); - wuffs_base__status z = wuffs_adler32__hasher__check_wuffs_version( + const char* z = wuffs_adler32__hasher__check_wuffs_version( &checksum, sizeof checksum, WUFFS_VERSION); if (z) { return z; @@ -237,30 +235,32 @@ const char* wuffs_bench_adler32(wuffs_base__io_buffer* dst, return NULL; } -void bench_wuffs_adler32_10k() { +const char* bench_wuffs_adler32_10k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(wuffs_bench_adler32, tc_src, &adler32_midsummer_gt, 0, 0, - 1500); + return do_bench_io_buffers(wuffs_bench_adler32, tc_src, &adler32_midsummer_gt, + 0, 0, 1500); } -void bench_wuffs_adler32_100k() { +const char* bench_wuffs_adler32_100k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(wuffs_bench_adler32, tc_src, &adler32_pi_gt, 0, 0, 150); + return do_bench_io_buffers(wuffs_bench_adler32, tc_src, &adler32_pi_gt, 0, 0, + 150); } // ---------------- Mimic Benches #ifdef WUFFS_MIMIC -void bench_mimic_adler32_10k() { +const char* bench_mimic_adler32_10k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(mimic_bench_adler32, tc_src, &adler32_midsummer_gt, 0, 0, - 1500); + return do_bench_io_buffers(mimic_bench_adler32, tc_src, &adler32_midsummer_gt, + 0, 0, 1500); } -void bench_mimic_adler32_100k() { +const char* bench_mimic_adler32_100k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(mimic_bench_adler32, tc_src, &adler32_pi_gt, 0, 0, 150); + return do_bench_io_buffers(mimic_bench_adler32, tc_src, &adler32_pi_gt, 0, 0, + 150); } #endif // WUFFS_MIMIC diff --git a/test/c/std/crc32.c b/test/c/std/crc32.c index 455d7280..fc837e85 100644 --- a/test/c/std/crc32.c +++ b/test/c/std/crc32.c @@ -77,7 +77,7 @@ golden_test crc32_pi_gt = { // ---------------- CRC32 Tests -void test_wuffs_crc32_ieee_golden() { +const char* test_wuffs_crc32_ieee_golden() { CHECK_FOCUS(__func__); struct { @@ -120,18 +120,18 @@ void test_wuffs_crc32_ieee_golden() { wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ .data = global_src_slice, }); - if (!read_file(&src, test_cases[i].filename)) { - return; + const char* z = read_file(&src, test_cases[i].filename); + if (z) { + return z; } int j; for (j = 0; j < 2; j++) { wuffs_crc32__ieee_hasher checksum = ((wuffs_crc32__ieee_hasher){}); - wuffs_base__status z = wuffs_crc32__ieee_hasher__check_wuffs_version( + z = wuffs_crc32__ieee_hasher__check_wuffs_version( &checksum, sizeof checksum, WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } uint32_t got = 0; @@ -152,23 +152,22 @@ void test_wuffs_crc32_ieee_golden() { } while (num_bytes < src.meta.wi); if (got != test_cases[i].want) { - FAIL("i=%d, j=%d, filename=\"%s\": got 0x%08" PRIX32 - ", want 0x%08" PRIX32 "\n", - i, j, test_cases[i].filename, got, test_cases[i].want); - return; + RETURN_FAIL("i=%d, j=%d, filename=\"%s\": got 0x%08" PRIX32 + ", want 0x%08" PRIX32, + i, j, test_cases[i].filename, got, test_cases[i].want); } } } + return NULL; } -void test_wuffs_crc32_ieee_pi() { +const char* test_wuffs_crc32_ieee_pi() { CHECK_FOCUS(__func__); const char* digits = "3.1415926535897932384626433832795028841971693993751058209749445"; if (strlen(digits) != 63) { - FAIL("strlen(digits): got %d, want 63", (int)(strlen(digits))); - return; + RETURN_FAIL("strlen(digits): got %d, want 63", (int)(strlen(digits))); } // The want values are determined by script/checksum.go. @@ -191,11 +190,10 @@ void test_wuffs_crc32_ieee_pi() { int i; for (i = 0; i < 64; i++) { wuffs_crc32__ieee_hasher checksum = ((wuffs_crc32__ieee_hasher){}); - wuffs_base__status z = wuffs_crc32__ieee_hasher__check_wuffs_version( + const char* z = wuffs_crc32__ieee_hasher__check_wuffs_version( &checksum, sizeof checksum, WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } uint32_t got = wuffs_crc32__ieee_hasher__update( &checksum, ((wuffs_base__slice_u8){ @@ -203,11 +201,11 @@ void test_wuffs_crc32_ieee_pi() { .len = i, })); if (got != wants[i]) { - FAIL("i=%d: got 0x%08" PRIX32 ", want 0x%08" PRIX32 "\n", i, got, - wants[i]); - return; + RETURN_FAIL("i=%d: got 0x%08" PRIX32 ", want 0x%08" PRIX32, i, got, + wants[i]); } } + return NULL; } // ---------------- CRC32 Benches @@ -223,7 +221,7 @@ 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){}); - wuffs_base__status z = wuffs_crc32__ieee_hasher__check_wuffs_version( + const char* z = wuffs_crc32__ieee_hasher__check_wuffs_version( &checksum, sizeof checksum, WUFFS_VERSION); if (z) { return z; @@ -237,30 +235,32 @@ const char* wuffs_bench_crc32_ieee(wuffs_base__io_buffer* dst, return NULL; } -void bench_wuffs_crc32_ieee_10k() { +const char* bench_wuffs_crc32_ieee_10k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(wuffs_bench_crc32_ieee, tc_src, &crc32_midsummer_gt, 0, 0, - 1500); + return do_bench_io_buffers(wuffs_bench_crc32_ieee, tc_src, + &crc32_midsummer_gt, 0, 0, 1500); } -void bench_wuffs_crc32_ieee_100k() { +const char* bench_wuffs_crc32_ieee_100k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(wuffs_bench_crc32_ieee, tc_src, &crc32_pi_gt, 0, 0, 150); + return do_bench_io_buffers(wuffs_bench_crc32_ieee, tc_src, &crc32_pi_gt, 0, 0, + 150); } // ---------------- Mimic Benches #ifdef WUFFS_MIMIC -void bench_mimic_crc32_ieee_10k() { +const char* bench_mimic_crc32_ieee_10k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(mimic_bench_crc32_ieee, tc_src, &crc32_midsummer_gt, 0, 0, - 1500); + return do_bench_io_buffers(mimic_bench_crc32_ieee, tc_src, + &crc32_midsummer_gt, 0, 0, 1500); } -void bench_mimic_crc32_ieee_100k() { +const char* bench_mimic_crc32_ieee_100k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(mimic_bench_crc32_ieee, tc_src, &crc32_pi_gt, 0, 0, 150); + return do_bench_io_buffers(mimic_bench_crc32_ieee, tc_src, &crc32_pi_gt, 0, 0, + 150); } #endif // WUFFS_MIMIC diff --git a/test/c/std/deflate.c b/test/c/std/deflate.c index a0e9221a..4d735c82 100644 --- a/test/c/std/deflate.c +++ b/test/c/std/deflate.c @@ -131,11 +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){}); - wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version( - &dec, sizeof dec, WUFFS_VERSION); + const char* z = wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec, + WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return false; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } while (true) { @@ -148,8 +147,7 @@ const char* wuffs_deflate_decode(wuffs_base__io_buffer* dst, set_reader_limit(&src_reader, rlimit); } - wuffs_base__status z = - wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader); + z = wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader); if ((wlimit && (z == wuffs_base__suspension__short_write)) || (rlimit && (z == wuffs_base__suspension__short_read))) { @@ -159,59 +157,60 @@ const char* wuffs_deflate_decode(wuffs_base__io_buffer* dst, } } -void test_wuffs_deflate_decode_256_bytes() { +const char* test_wuffs_deflate_decode_256_bytes() { CHECK_FOCUS(__func__); - do_test_io_buffers(wuffs_deflate_decode, &deflate_256_bytes_gt, 0, 0); + return do_test_io_buffers(wuffs_deflate_decode, &deflate_256_bytes_gt, 0, 0); } -void test_wuffs_deflate_decode_deflate_backref_crosses_blocks() { +const char* test_wuffs_deflate_decode_deflate_backref_crosses_blocks() { CHECK_FOCUS(__func__); - do_test_io_buffers(wuffs_deflate_decode, - &deflate_deflate_backref_crosses_blocks_gt, 0, 0); + return do_test_io_buffers(wuffs_deflate_decode, + &deflate_deflate_backref_crosses_blocks_gt, 0, 0); } -void test_wuffs_deflate_decode_deflate_distance_32768() { +const char* test_wuffs_deflate_decode_deflate_distance_32768() { CHECK_FOCUS(__func__); - do_test_io_buffers(wuffs_deflate_decode, &deflate_deflate_distance_32768_gt, - 0, 0); + return do_test_io_buffers(wuffs_deflate_decode, + &deflate_deflate_distance_32768_gt, 0, 0); } -void test_wuffs_deflate_decode_midsummer() { +const char* test_wuffs_deflate_decode_midsummer() { CHECK_FOCUS(__func__); - do_test_io_buffers(wuffs_deflate_decode, &deflate_midsummer_gt, 0, 0); + return do_test_io_buffers(wuffs_deflate_decode, &deflate_midsummer_gt, 0, 0); } -void test_wuffs_deflate_decode_pi() { +const char* test_wuffs_deflate_decode_pi() { CHECK_FOCUS(__func__); - do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 0, 0); + return do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 0, 0); } -void test_wuffs_deflate_decode_pi_many_big_reads() { +const char* test_wuffs_deflate_decode_pi_many_big_reads() { CHECK_FOCUS(__func__); - do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 0, 4096); + return do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 0, 4096); } -void test_wuffs_deflate_decode_pi_many_medium_reads() { +const char* test_wuffs_deflate_decode_pi_many_medium_reads() { CHECK_FOCUS(__func__); - do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 0, 599); + return do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 0, 599); } -void test_wuffs_deflate_decode_pi_many_small_writes_reads() { +const char* test_wuffs_deflate_decode_pi_many_small_writes_reads() { CHECK_FOCUS(__func__); - do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 59, 61); + return do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 59, 61); } -void test_wuffs_deflate_decode_romeo() { +const char* test_wuffs_deflate_decode_romeo() { CHECK_FOCUS(__func__); - do_test_io_buffers(wuffs_deflate_decode, &deflate_romeo_gt, 0, 0); + return do_test_io_buffers(wuffs_deflate_decode, &deflate_romeo_gt, 0, 0); } -void test_wuffs_deflate_decode_romeo_fixed() { +const char* test_wuffs_deflate_decode_romeo_fixed() { CHECK_FOCUS(__func__); - do_test_io_buffers(wuffs_deflate_decode, &deflate_romeo_fixed_gt, 0, 0); + return do_test_io_buffers(wuffs_deflate_decode, &deflate_romeo_fixed_gt, 0, + 0); } -void test_wuffs_deflate_decode_split_src() { +const char* test_wuffs_deflate_decode_split_src() { CHECK_FOCUS(__func__); wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ @@ -224,12 +223,15 @@ void test_wuffs_deflate_decode_split_src() { .data = global_want_slice, }); + const char* z; golden_test* gt = &deflate_256_bytes_gt; - if (!read_file(&src, gt->src_filename)) { - return; + z = read_file(&src, gt->src_filename); + if (z) { + return z; } - if (!read_file(&want, gt->want_filename)) { - return; + z = read_file(&want, gt->want_filename); + if (z) { + return z; } wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(&got); @@ -239,58 +241,56 @@ void test_wuffs_deflate_decode_split_src() { for (i = 1; i < 32; i++) { size_t split = gt->src_offset0 + i; if (split >= gt->src_offset1) { - FAIL("i=%d: split was not an interior split", i); - return; + RETURN_FAIL("i=%d: split was not an interior split", i); } got.meta.wi = 0; wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){}); - wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version( - &dec, sizeof dec, WUFFS_VERSION); + z = wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec, + WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } src.meta.closed = false; src.meta.ri = gt->src_offset0; src.meta.wi = split; - wuffs_base__status z0 = + const char* z0 = wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader); src.meta.closed = true; src.meta.ri = split; src.meta.wi = gt->src_offset1; - wuffs_base__status z1 = + const char* z1 = wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader); if (z0 != wuffs_base__suspension__short_read) { - FAIL("i=%d: z0: got \"%s\", want \"%s\"", i, z0, - wuffs_base__suspension__short_read); - return; + RETURN_FAIL("i=%d: z0: got \"%s\", want \"%s\"", i, z0, + wuffs_base__suspension__short_read); } if (z1) { - FAIL("i=%d: z1: got \"%s\"", i, z1); - return; + RETURN_FAIL("i=%d: z1: got \"%s\"", i, z1); } char prefix[64]; snprintf(prefix, 64, "i=%d: ", i); - if (!io_buffers_equal(prefix, &got, &want)) { - return; + z = check_io_buffers_equal(prefix, &got, &want); + if (z) { + return z; } } + return NULL; } -bool do_test_wuffs_deflate_history(int i, - golden_test* gt, - wuffs_base__io_buffer* src, - wuffs_base__io_buffer* got, - wuffs_deflate__decoder* dec, - uint32_t starting_history_index, - uint64_t limit, - const char* want_z) { +const char* do_test_wuffs_deflate_history(int i, + golden_test* gt, + wuffs_base__io_buffer* src, + wuffs_base__io_buffer* got, + wuffs_deflate__decoder* dec, + uint32_t starting_history_index, + uint64_t limit, + const char* want_z) { src->meta.ri = gt->src_offset0; src->meta.wi = gt->src_offset1; got->meta.ri = 0; @@ -303,18 +303,17 @@ bool do_test_wuffs_deflate_history(int i, set_writer_limit(&dst_writer, limit); - wuffs_base__status got_z = + const char* got_z = wuffs_deflate__decoder__decode(dec, dst_writer, src_reader); if (got_z != want_z) { - FAIL("i=%d: starting_history_index=0x%04" PRIX32 - ": decode status: got \"%s\", want \"%s\"", - i, starting_history_index, got_z, want_z); - return false; + RETURN_FAIL("i=%d: starting_history_index=0x%04" PRIX32 + ": decode status: got \"%s\", want \"%s\"", + i, starting_history_index, got_z, want_z); } - return true; + return NULL; } -void test_wuffs_deflate_history_full() { +const char* test_wuffs_deflate_history_full() { CHECK_FOCUS(__func__); wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ @@ -327,36 +326,38 @@ void test_wuffs_deflate_history_full() { .data = global_want_slice, }); + const char* z; golden_test* gt = &deflate_pi_gt; - if (!read_file(&src, gt->src_filename)) { - return; + z = read_file(&src, gt->src_filename); + if (z) { + return z; } - if (!read_file(&want, gt->want_filename)) { - return; + z = read_file(&want, gt->want_filename); + if (z) { + return z; } const int full_history_size = 0x8000; int i; for (i = -2; i <= +2; i++) { wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){}); - wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version( - &dec, sizeof dec, WUFFS_VERSION); + z = wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec, + WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } - if (!do_test_wuffs_deflate_history( - i, gt, &src, &got, &dec, 0, want.meta.wi + i, - i >= 0 ? NULL : wuffs_base__suspension__short_write)) { - return; + z = 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; } uint32_t want_history_index = i >= 0 ? 0 : full_history_size; if (dec.private_impl.f_history_index != want_history_index) { - FAIL("i=%d: history_index: got %" PRIu32 ", want %" PRIu32, i, - dec.private_impl.f_history_index, want_history_index); - return; + RETURN_FAIL("i=%d: history_index: got %" PRIu32 ", want %" PRIu32, i, + dec.private_impl.f_history_index, want_history_index); } if (i >= 0) { continue; @@ -370,8 +371,7 @@ void test_wuffs_deflate_history_full() { }); history_got.meta.wi = full_history_size; if (want.meta.wi < full_history_size - i) { - FAIL("i=%d: want file is too short", i); - return; + RETURN_FAIL("i=%d: want file is too short", i); } wuffs_base__io_buffer history_want = ((wuffs_base__io_buffer){ .data = ((wuffs_base__slice_u8){ @@ -380,13 +380,16 @@ void test_wuffs_deflate_history_full() { }), }); history_want.meta.wi = full_history_size; - if (!io_buffers_equal("", &history_got, &history_want)) { - return; + + z = check_io_buffers_equal("", &history_got, &history_want); + if (z) { + return z; } } + return NULL; } -void test_wuffs_deflate_history_partial() { +const char* test_wuffs_deflate_history_partial() { CHECK_FOCUS(__func__); wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ @@ -397,8 +400,9 @@ void test_wuffs_deflate_history_partial() { }); golden_test* gt = &deflate_pi_gt; - if (!read_file(&src, gt->src_filename)) { - return; + const char* z = read_file(&src, gt->src_filename); + if (z) { + return z; } uint32_t starting_history_indexes[] = { @@ -415,17 +419,17 @@ void test_wuffs_deflate_history_partial() { const uint32_t fragment_length = 4; wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){}); - wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version( - &dec, sizeof dec, WUFFS_VERSION); + z = wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec, + WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } - if (!do_test_wuffs_deflate_history(i, gt, &src, &got, &dec, - starting_history_index, fragment_length, - wuffs_base__suspension__short_write)) { - return; + 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; } bool got_full = dec.private_impl.f_history_index >= 0x8000; @@ -434,11 +438,10 @@ void test_wuffs_deflate_history_partial() { uint32_t want_history_index = (starting_history_index + fragment_length) & 0x7FFF; if ((got_full != want_full) || (got_history_index != want_history_index)) { - FAIL("i=%d: starting_history_index=0x%04" PRIX32 - ": history_index: got %d;%04" PRIX32 ", want %d;%04" PRIX32, - i, starting_history_index, (int)(got_full), got_history_index, - (int)(want_full), want_history_index); - return; + RETURN_FAIL("i=%d: starting_history_index=0x%04" PRIX32 + ": history_index: got %d;%04" PRIX32 ", want %d;%04" PRIX32, + i, starting_history_index, (int)(got_full), got_history_index, + (int)(want_full), want_history_index); } int j; @@ -447,16 +450,16 @@ void test_wuffs_deflate_history_partial() { uint8_t got = dec.private_impl.f_history[index]; uint8_t want = (0 <= j && j < fragment_length) ? fragment[j] : 0; if (got != want) { - FAIL("i=%d: starting_history_index=0x%04" PRIX32 - ": j=%d: got 0x%02" PRIX8 ", want 0x%02" PRIX8, - i, starting_history_index, j, got, want); - return; + RETURN_FAIL("i=%d: starting_history_index=0x%04" PRIX32 + ": j=%d: got 0x%02" PRIX8 ", want 0x%02" PRIX8, + i, starting_history_index, j, got, want); } } } + return NULL; } -void test_wuffs_deflate_table_redirect() { +const char* test_wuffs_deflate_table_redirect() { CHECK_FOCUS(__func__); // Call init_huff with a Huffman code that looks like: @@ -503,11 +506,10 @@ void test_wuffs_deflate_table_redirect() { // 2nd is the key in the second level table (variable bits). wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){}); - wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version( - &dec, sizeof dec, WUFFS_VERSION); + const char* z = wuffs_deflate__decoder__check_wuffs_version(&dec, sizeof dec, + WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } int i; @@ -529,8 +531,7 @@ void test_wuffs_deflate_table_redirect() { z = wuffs_deflate__decoder__init_huff(&dec, 0, 0, n, 257); if (z) { - FAIL("init_huff: \"%s\"", z); - return; + RETURN_FAIL("init_huff: \"%s\"", z); } // There is one 1st-level table (9 bits), and three 2nd-level tables (3, 3 @@ -542,8 +543,7 @@ void test_wuffs_deflate_table_redirect() { bool got = dec.private_impl.f_huffs[0][i] == 0; bool want = i >= (1 << 9) + (1 << 3) + (1 << 3) + (1 << 4); if (got != want) { - FAIL("huffs[0][%d] == 0: got %d, want %d", i, got, want); - return; + RETURN_FAIL("huffs[0][%d] == 0: got %d, want %d", i, got, want); } } @@ -556,20 +556,20 @@ void test_wuffs_deflate_table_redirect() { got = dec.private_impl.f_huffs[0][0x017F]; want = 0x10020039; if (got != want) { - FAIL("huffs[0][0x017F]: got 0x%08" PRIX32 ", want 0x%08" PRIX32, got, want); - return; + RETURN_FAIL("huffs[0][0x017F]: got 0x%08" PRIX32 ", want 0x%08" PRIX32, got, + want); } got = dec.private_impl.f_huffs[0][0x00FF]; want = 0x10020839; if (got != want) { - FAIL("huffs[0][0x00FF]: got 0x%08" PRIX32 ", want 0x%08" PRIX32, got, want); - return; + RETURN_FAIL("huffs[0][0x00FF]: got 0x%08" PRIX32 ", want 0x%08" PRIX32, got, + want); } got = dec.private_impl.f_huffs[0][0x01FF]; want = 0x10021049; if (got != want) { - FAIL("huffs[0][0x01FF]: got 0x%08" PRIX32 ", want 0x%08" PRIX32, got, want); - return; + RETURN_FAIL("huffs[0][0x01FF]: got 0x%08" PRIX32 ", want 0x%08" PRIX32, got, + want); } // The first 2nd-level table should look like wants. @@ -581,94 +581,98 @@ void test_wuffs_deflate_table_redirect() { got = dec.private_impl.f_huffs[0][0x0200 + i]; want = wants[i]; if (got != want) { - FAIL("huffs[0][0x%04" PRIX32 "]: got 0x%08" PRIX32 ", want 0x%08" PRIX32, - (uint32_t)(0x0200 + i), got, want); - return; + RETURN_FAIL("huffs[0][0x%04" PRIX32 "]: got 0x%08" PRIX32 + ", want 0x%08" PRIX32, + (uint32_t)(0x0200 + i), got, want); } } + return NULL; } // ---------------- Mimic Tests #ifdef WUFFS_MIMIC -void test_mimic_deflate_decode_256_bytes() { +const char* test_mimic_deflate_decode_256_bytes() { CHECK_FOCUS(__func__); - do_test_io_buffers(mimic_deflate_decode, &deflate_256_bytes_gt, 0, 0); + return do_test_io_buffers(mimic_deflate_decode, &deflate_256_bytes_gt, 0, 0); } -void test_mimic_deflate_decode_deflate_backref_crosses_blocks() { +const char* test_mimic_deflate_decode_deflate_backref_crosses_blocks() { CHECK_FOCUS(__func__); - do_test_io_buffers(mimic_deflate_decode, - &deflate_deflate_backref_crosses_blocks_gt, 0, 0); + return do_test_io_buffers(mimic_deflate_decode, + &deflate_deflate_backref_crosses_blocks_gt, 0, 0); } -void test_mimic_deflate_decode_deflate_distance_32768() { +const char* test_mimic_deflate_decode_deflate_distance_32768() { CHECK_FOCUS(__func__); - do_test_io_buffers(mimic_deflate_decode, &deflate_deflate_distance_32768_gt, - 0, 0); + return do_test_io_buffers(mimic_deflate_decode, + &deflate_deflate_distance_32768_gt, 0, 0); } -void test_mimic_deflate_decode_midsummer() { +const char* test_mimic_deflate_decode_midsummer() { CHECK_FOCUS(__func__); - do_test_io_buffers(mimic_deflate_decode, &deflate_midsummer_gt, 0, 0); + return do_test_io_buffers(mimic_deflate_decode, &deflate_midsummer_gt, 0, 0); } -void test_mimic_deflate_decode_pi() { +const char* test_mimic_deflate_decode_pi() { CHECK_FOCUS(__func__); - do_test_io_buffers(mimic_deflate_decode, &deflate_pi_gt, 0, 0); + return do_test_io_buffers(mimic_deflate_decode, &deflate_pi_gt, 0, 0); } -void test_mimic_deflate_decode_romeo() { +const char* test_mimic_deflate_decode_romeo() { CHECK_FOCUS(__func__); - do_test_io_buffers(mimic_deflate_decode, &deflate_romeo_gt, 0, 0); + return do_test_io_buffers(mimic_deflate_decode, &deflate_romeo_gt, 0, 0); } -void test_mimic_deflate_decode_romeo_fixed() { +const char* test_mimic_deflate_decode_romeo_fixed() { CHECK_FOCUS(__func__); - do_test_io_buffers(mimic_deflate_decode, &deflate_romeo_fixed_gt, 0, 0); + return do_test_io_buffers(mimic_deflate_decode, &deflate_romeo_fixed_gt, 0, + 0); } #endif // WUFFS_MIMIC // ---------------- Deflate Benches -void bench_wuffs_deflate_decode_1k() { +const char* bench_wuffs_deflate_decode_1k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(wuffs_deflate_decode, tc_dst, &deflate_romeo_gt, 0, 0, - 2000); + return do_bench_io_buffers(wuffs_deflate_decode, tc_dst, &deflate_romeo_gt, 0, + 0, 2000); } -void bench_wuffs_deflate_decode_10k() { +const char* bench_wuffs_deflate_decode_10k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(wuffs_deflate_decode, tc_dst, &deflate_midsummer_gt, 0, 0, - 300); + return do_bench_io_buffers(wuffs_deflate_decode, tc_dst, + &deflate_midsummer_gt, 0, 0, 300); } -void bench_wuffs_deflate_decode_100k() { +const char* bench_wuffs_deflate_decode_100k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(wuffs_deflate_decode, tc_dst, &deflate_pi_gt, 0, 0, 30); + return do_bench_io_buffers(wuffs_deflate_decode, tc_dst, &deflate_pi_gt, 0, 0, + 30); } // ---------------- Mimic Benches #ifdef WUFFS_MIMIC -void bench_mimic_deflate_decode_1k() { +const char* bench_mimic_deflate_decode_1k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(mimic_deflate_decode, tc_dst, &deflate_romeo_gt, 0, 0, - 2000); + return do_bench_io_buffers(mimic_deflate_decode, tc_dst, &deflate_romeo_gt, 0, + 0, 2000); } -void bench_mimic_deflate_decode_10k() { +const char* bench_mimic_deflate_decode_10k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(mimic_deflate_decode, tc_dst, &deflate_midsummer_gt, 0, 0, - 300); + return do_bench_io_buffers(mimic_deflate_decode, tc_dst, + &deflate_midsummer_gt, 0, 0, 300); } -void bench_mimic_deflate_decode_100k() { +const char* bench_mimic_deflate_decode_100k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(mimic_deflate_decode, tc_dst, &deflate_pi_gt, 0, 0, 30); + return do_bench_io_buffers(mimic_deflate_decode, tc_dst, &deflate_pi_gt, 0, 0, + 30); } #endif // WUFFS_MIMIC diff --git a/test/c/std/gif.c b/test/c/std/gif.c index 0b02e0bc..0606083b 100644 --- a/test/c/std/gif.c +++ b/test/c/std/gif.c @@ -68,128 +68,121 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the // ---------------- Basic Tests -void test_basic_bad_receiver() { +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){}); - wuffs_base__status z = - wuffs_gif__decoder__decode_image_config(NULL, &ic, src); + const char* z = wuffs_gif__decoder__decode_image_config(NULL, &ic, src); if (z != wuffs_base__error__bad_receiver) { - FAIL("decode_image_config: got \"%s\", want \"%s\"", z, - wuffs_base__error__bad_receiver); + RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", z, + wuffs_base__error__bad_receiver); } + return NULL; } -void test_basic_bad_sizeof_receiver() { +const char* test_basic_bad_sizeof_receiver() { CHECK_FOCUS(__func__); wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_base__status z = + const char* z = wuffs_gif__decoder__check_wuffs_version(&dec, 0, WUFFS_VERSION); if (z != wuffs_base__error__bad_sizeof_receiver) { - FAIL("decode_image_config: got \"%s\", want \"%s\"", z, - wuffs_base__error__bad_sizeof_receiver); - return; + RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", z, + wuffs_base__error__bad_sizeof_receiver); } + return NULL; } -void test_basic_bad_wuffs_version() { +const char* test_basic_bad_wuffs_version() { CHECK_FOCUS(__func__); wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_base__status z = wuffs_gif__decoder__check_wuffs_version( + const char* z = wuffs_gif__decoder__check_wuffs_version( &dec, sizeof dec, WUFFS_VERSION ^ 0x123456789ABC); if (z != wuffs_base__error__bad_wuffs_version) { - FAIL("decode_image_config: got \"%s\", want \"%s\"", z, - wuffs_base__error__bad_wuffs_version); - return; + RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", z, + wuffs_base__error__bad_wuffs_version); } + return NULL; } -void test_basic_check_wuffs_version_not_called() { +const char* test_basic_check_wuffs_version_not_called() { CHECK_FOCUS(__func__); 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){}); - wuffs_base__status z = - wuffs_gif__decoder__decode_image_config(&dec, &ic, src); + const char* z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src); if (z != wuffs_base__error__check_wuffs_version_missing) { - FAIL("decode_image_config: got \"%s\", want \"%s\"", z, - wuffs_base__error__check_wuffs_version_missing); + RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", z, + wuffs_base__error__check_wuffs_version_missing); } + return NULL; } -void test_basic_status_is_error() { +const char* test_basic_status_is_error() { CHECK_FOCUS(__func__); if (wuffs_base__status__is_error(NULL)) { - FAIL("is_error(NULL) returned true"); - return; + RETURN_FAIL("is_error(NULL) returned true"); } if (!wuffs_base__status__is_error(wuffs_base__error__bad_wuffs_version)) { - FAIL("is_error(BAD_WUFFS_VERSION) returned false"); - return; + RETURN_FAIL("is_error(BAD_WUFFS_VERSION) returned false"); } if (wuffs_base__status__is_error(wuffs_base__suspension__short_write)) { - FAIL("is_error(SHORT_WRITE) returned true"); - return; + RETURN_FAIL("is_error(SHORT_WRITE) returned true"); } if (!wuffs_base__status__is_error(wuffs_gif__error__bad_header)) { - FAIL("is_error(BAD_HEADER) returned false"); - return; + RETURN_FAIL("is_error(BAD_HEADER) returned false"); } + return NULL; } -void test_basic_status_strings() { +const char* test_basic_status_strings() { CHECK_FOCUS(__func__); const char* s1 = wuffs_base__error__bad_wuffs_version; const char* t1 = "?base: bad wuffs version"; if (strcmp(s1, t1)) { - FAIL("got \"%s\", want \"%s\"", s1, t1); - return; + RETURN_FAIL("got \"%s\", want \"%s\"", s1, t1); } const char* s2 = wuffs_base__suspension__short_write; const char* t2 = "$base: short write"; if (strcmp(s2, t2)) { - FAIL("got \"%s\", want \"%s\"", s2, t2); - return; + RETURN_FAIL("got \"%s\", want \"%s\"", s2, t2); } const char* s3 = wuffs_gif__error__bad_header; const char* t3 = "?gif: bad header"; if (strcmp(s3, t3)) { - FAIL("got \"%s\", want \"%s\"", s3, t3); - return; + RETURN_FAIL("got \"%s\", want \"%s\"", s3, t3); } + return NULL; } -void test_basic_status_used_package() { +const char* test_basic_status_used_package() { CHECK_FOCUS(__func__); // The function call here is from "std/gif" but the argument is from // "std/lzw". The former package depends on the latter. const char* s0 = wuffs_lzw__error__bad_code; const char* t0 = "?lzw: bad code"; if (strcmp(s0, t0)) { - FAIL("got \"%s\", want \"%s\"", s0, t0); - return; + RETURN_FAIL("got \"%s\", want \"%s\"", s0, t0); } + return NULL; } -void test_basic_sub_struct_initializer() { +const char* test_basic_sub_struct_initializer() { CHECK_FOCUS(__func__); wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_base__status z = + const char* z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } if (dec.private_impl.magic != WUFFS_BASE__MAGIC) { - FAIL("outer magic: got %" PRIu32 ", want %" PRIu32 "", - dec.private_impl.magic, WUFFS_BASE__MAGIC); - return; + RETURN_FAIL("outer magic: got %" PRIu32 ", want %" PRIu32 "", + dec.private_impl.magic, WUFFS_BASE__MAGIC); } if (dec.private_impl.f_lzw.private_impl.magic != WUFFS_BASE__MAGIC) { - FAIL("inner magic: got %" PRIu32 ", want %" PRIu32, - dec.private_impl.f_lzw.private_impl.magic, WUFFS_BASE__MAGIC); - return; + RETURN_FAIL("inner magic: got %" PRIu32 ", want %" PRIu32, + dec.private_impl.f_lzw.private_impl.magic, WUFFS_BASE__MAGIC); } + return NULL; } // ---------------- GIF Tests @@ -197,7 +190,7 @@ void test_basic_sub_struct_initializer() { const char* wuffs_gif_decode(wuffs_base__io_buffer* dst, wuffs_base__io_buffer* src) { wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_base__status z = + const char* z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); if (z) { return z; @@ -229,10 +222,9 @@ const char* wuffs_gif_decode(wuffs_base__io_buffer* dst, while (true) { z = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader); - if (z) { - if (z == wuffs_base__warning__end_of_data) { - break; - } + if (z == wuffs_base__warning__end_of_data) { + break; + } else if (z) { return z; } @@ -241,19 +233,19 @@ const char* wuffs_gif_decode(wuffs_base__io_buffer* dst, return z; } - const char* msg = copy_to_io_buffer_from_pixel_buffer( + z = copy_to_io_buffer_from_pixel_buffer( dst, &pb, wuffs_base__frame_config__bounds(&fc)); - if (msg) { - return msg; + if (z) { + return z; } } return NULL; } -bool do_test_wuffs_gif_decode(const char* filename, - const char* palette_filename, - const char* indexes_filename, - uint64_t rlimit) { +const char* do_test_wuffs_gif_decode(const char* filename, + const char* palette_filename, + const char* indexes_filename, + uint64_t rlimit) { wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ .data = global_got_slice, }); @@ -261,16 +253,15 @@ bool do_test_wuffs_gif_decode(const char* filename, .data = global_src_slice, }); - if (!read_file(&src, filename)) { - return false; + const char* z = read_file(&src, filename); + if (z) { + return z; } wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_base__status z = - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return false; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } wuffs_base__frame_config fc = ((wuffs_base__frame_config){}); @@ -281,47 +272,39 @@ bool do_test_wuffs_gif_decode(const char* filename, 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) { - FAIL("decode_image_config: got \"%s\"", z); - return false; + RETURN_FAIL("decode_image_config: got \"%s\"", z); } if (wuffs_base__pixel_config__pixel_format(&ic.pixcfg) != WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL) { - FAIL("pixel_format: got 0x%08" PRIX32 ", want 0x%08" PRIX32, - wuffs_base__pixel_config__pixel_format(&ic.pixcfg), - WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL); - return false; + RETURN_FAIL("pixel_format: got 0x%08" PRIX32 ", want 0x%08" PRIX32, + wuffs_base__pixel_config__pixel_format(&ic.pixcfg), + WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL); } // bricks-dither.gif is a 160 × 120, opaque, still (not animated) GIF. if (wuffs_base__pixel_config__width(&ic.pixcfg) != 160) { - FAIL("width: got %" PRIu32 ", want 160", - wuffs_base__pixel_config__width(&ic.pixcfg)); - return false; + RETURN_FAIL("width: got %" PRIu32 ", want 160", + wuffs_base__pixel_config__width(&ic.pixcfg)); } if (wuffs_base__pixel_config__height(&ic.pixcfg) != 120) { - FAIL("height: got %" PRIu32 ", want 120", - wuffs_base__pixel_config__height(&ic.pixcfg)); - return false; + RETURN_FAIL("height: got %" PRIu32 ", want 120", + wuffs_base__pixel_config__height(&ic.pixcfg)); } if (wuffs_base__image_config__workbuf_len(&ic).max_incl != 160) { - FAIL("workbuf_len: got %" PRIu64 ", want 160", - wuffs_base__image_config__workbuf_len(&ic).max_incl); - return false; + RETURN_FAIL("workbuf_len: got %" PRIu64 ", want 160", + wuffs_base__image_config__workbuf_len(&ic).max_incl); } if (wuffs_base__image_config__num_loops(&ic) != 1) { - FAIL("num_loops: got %" PRIu32 ", want 1", - wuffs_base__image_config__num_loops(&ic)); - return false; + RETURN_FAIL("num_loops: got %" PRIu32 ", want 1", + wuffs_base__image_config__num_loops(&ic)); } if (!wuffs_base__image_config__first_frame_is_opaque(&ic)) { - FAIL("first_frame_is_opaque: got false, want true"); - return false; + RETURN_FAIL("first_frame_is_opaque: got false, want true"); } z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg, global_pixel_slice); if (z) { - FAIL("set_from_slice: \"%s\"", z); - return false; + RETURN_FAIL("set_from_slice: \"%s\"", z); } } @@ -339,25 +322,21 @@ bool do_test_wuffs_gif_decode(const char* filename, } size_t old_ri = src.meta.ri; - wuffs_base__status z = - wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader); + z = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader); if (!z) { break; } if (z != wuffs_base__suspension__short_read) { - FAIL("decode_frame_config: got \"%s\", want \"%s\"", z, - wuffs_base__suspension__short_read); - return false; + RETURN_FAIL("decode_frame_config: got \"%s\", want \"%s\"", z, + wuffs_base__suspension__short_read); } if (src.meta.ri < old_ri) { - FAIL("read index src.meta.ri went backwards"); - return false; + RETURN_FAIL("read index src.meta.ri went backwards"); } if (src.meta.ri == old_ri) { - FAIL("no progress was made"); - return false; + RETURN_FAIL("no progress was made"); } } @@ -369,46 +348,38 @@ bool do_test_wuffs_gif_decode(const char* filename, } size_t old_ri = src.meta.ri; - wuffs_base__status z = + const char* z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader, workbuf, NULL); if (!z) { break; } if (z != wuffs_base__suspension__short_read) { - FAIL("decode_frame: got \"%s\", want \"%s\"", z, - wuffs_base__suspension__short_read); - return false; + RETURN_FAIL("decode_frame: got \"%s\", want \"%s\"", z, + wuffs_base__suspension__short_read); } if (src.meta.ri < old_ri) { - FAIL("read index src.meta.ri went backwards"); - return false; + RETURN_FAIL("read index src.meta.ri went backwards"); } if (src.meta.ri == old_ri) { - FAIL("no progress was made"); - return false; + RETURN_FAIL("no progress was made"); } } - { - const char* msg = copy_to_io_buffer_from_pixel_buffer( - &got, &pb, wuffs_base__frame_config__bounds(&fc)); - if (msg) { - FAIL("%s", msg); - return false; - } + z = copy_to_io_buffer_from_pixel_buffer( + &got, &pb, wuffs_base__frame_config__bounds(&fc)); + if (z) { + return z; } if (rlimit) { if (num_iters <= 2) { - FAIL("num_iters: got %d, want > 2", num_iters); - return false; + RETURN_FAIL("num_iters: got %d, want > 2", num_iters); } } else { if (num_iters != 2) { - FAIL("num_iters: got %d, want 2", num_iters); - return false; + RETURN_FAIL("num_iters: got %d, want 2", num_iters); } } @@ -423,81 +394,80 @@ bool do_test_wuffs_gif_decode(const char* filename, .len = 1024, }), }); - if (!read_file(&pal_want, palette_filename)) { - return false; + z = read_file(&pal_want, palette_filename); + if (z) { + return z; } - if (!io_buffers_equal("palette ", &pal_got, &pal_want)) { - return false; + z = check_io_buffers_equal("palette ", &pal_got, &pal_want); + if (z) { + return z; } wuffs_base__io_buffer ind_want = ((wuffs_base__io_buffer){ .data = global_want_slice, }); - if (!read_file(&ind_want, indexes_filename)) { - return false; + z = read_file(&ind_want, indexes_filename); + if (z) { + return z; } - if (!io_buffers_equal("indexes ", &got, &ind_want)) { - return false; + z = check_io_buffers_equal("indexes ", &got, &ind_want); + if (z) { + return z; } { if (src.meta.ri == src.meta.wi) { - FAIL("decode_frame returned \"ok\" but src was exhausted"); - return false; + RETURN_FAIL("decode_frame returned \"ok\" but src was exhausted"); } wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); - wuffs_base__status z = - wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader, workbuf, NULL); + z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader, workbuf, NULL); if (z != wuffs_base__warning__end_of_data) { - FAIL("decode_frame: got \"%s\", want \"%s\"", z, - wuffs_base__warning__end_of_data); - return false; + RETURN_FAIL("decode_frame: got \"%s\", want \"%s\"", z, + wuffs_base__warning__end_of_data); } if (src.meta.ri != src.meta.wi) { - FAIL("decode_frame returned \"end of data\" but src was not exhausted"); - return false; + RETURN_FAIL( + "decode_frame returned \"end of data\" but src was not exhausted"); } } - return true; + return NULL; } -void test_wuffs_gif_call_sequence() { +const char* test_wuffs_gif_call_sequence() { CHECK_FOCUS(__func__); wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ .data = global_src_slice, }); - if (!read_file(&src, "../../data/bricks-dither.gif")) { - return; + const char* z = read_file(&src, "../../data/bricks-dither.gif"); + if (z) { + return z; } wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_base__status z = - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } 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) { - FAIL("decode_image_config: got \"%s\"", z); - return; + RETURN_FAIL("decode_image_config: got \"%s\"", z); } z = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader); if (z != wuffs_base__error__bad_call_sequence) { - FAIL("decode_image_config: got \"%s\", want \"%s\"", z, - wuffs_base__error__bad_call_sequence); - return; + RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", z, + wuffs_base__error__bad_call_sequence); } + return NULL; } -bool do_test_wuffs_gif_decode_animated( +const char* do_test_wuffs_gif_decode_animated( const char* filename, uint32_t want_num_loops, uint32_t want_num_frames, @@ -506,16 +476,15 @@ bool do_test_wuffs_gif_decode_animated( .data = global_src_slice, }); - if (!read_file(&src, filename)) { - return false; + const char* z = read_file(&src, filename); + if (z) { + return z; } wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_base__status z = - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return false; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } wuffs_base__image_config ic = ((wuffs_base__image_config){}); @@ -523,8 +492,7 @@ bool do_test_wuffs_gif_decode_animated( z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader); if (z) { - FAIL("decode_image_config: got \"%s\"", z); - return false; + RETURN_FAIL("decode_image_config: got \"%s\"", z); } uint64_t workbuf_len = wuffs_base__image_config__workbuf_len(&ic).max_incl; @@ -537,17 +505,15 @@ bool do_test_wuffs_gif_decode_animated( }); if (wuffs_base__image_config__num_loops(&ic) != want_num_loops) { - FAIL("num_loops: got %" PRIu32 ", want %" PRIu32, - wuffs_base__image_config__num_loops(&ic), want_num_loops); - return false; + RETURN_FAIL("num_loops: got %" PRIu32 ", want %" PRIu32, + wuffs_base__image_config__num_loops(&ic), want_num_loops); } 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) { - FAIL("set_from_slice: \"%s\"", z); - return false; + RETURN_FAIL("set_from_slice: \"%s\"", z); } uint32_t i; @@ -555,28 +521,25 @@ bool do_test_wuffs_gif_decode_animated( wuffs_base__frame_config fc = ((wuffs_base__frame_config){}); z = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader); if (z) { - FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i, z); - return false; + RETURN_FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i, z); } if (want_frame_config_bounds) { wuffs_base__rect_ie_u32 got = wuffs_base__frame_config__bounds(&fc); wuffs_base__rect_ie_u32 want = want_frame_config_bounds[i]; if (!wuffs_base__rect_ie_u32__equals(&got, want)) { - FAIL("decode_frame_config #%" PRIu32 ": bounds: got (%" PRIu32 - ", %" PRIu32 ")-(%" PRIu32 ", %" PRIu32 "), want (%" PRIu32 - ", %" PRIu32 ")-(%" PRIu32 ", %" PRIu32 ")", - i, got.min_incl_x, got.min_incl_y, got.max_excl_x, got.max_excl_y, - want.min_incl_x, want.min_incl_y, want.max_excl_x, - want.max_excl_y); - return false; + RETURN_FAIL("decode_frame_config #%" PRIu32 ": bounds: got (%" PRIu32 + ", %" PRIu32 ")-(%" PRIu32 ", %" PRIu32 "), want (%" PRIu32 + ", %" PRIu32 ")-(%" PRIu32 ", %" PRIu32 ")", + i, got.min_incl_x, got.min_incl_y, got.max_excl_x, + got.max_excl_y, want.min_incl_x, want.min_incl_y, + want.max_excl_x, want.max_excl_y); } } z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader, workbuf, NULL); if (z) { - FAIL("decode_frame #%" PRIu32 ": got \"%s\"", i, z); - return false; + RETURN_FAIL("decode_frame #%" PRIu32 ": got \"%s\"", i, z); } } @@ -585,35 +548,33 @@ bool do_test_wuffs_gif_decode_animated( for (i = 0; i < 3; i++) { z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader, workbuf, NULL); if (z != wuffs_base__warning__end_of_data) { - FAIL("decode_frame: got \"%s\", want \"%s\"", z, - wuffs_base__warning__end_of_data); - return false; + RETURN_FAIL("decode_frame: got \"%s\", want \"%s\"", z, + wuffs_base__warning__end_of_data); } } uint64_t got_num_frames = wuffs_gif__decoder__num_decoded_frames(&dec); if (got_num_frames != want_num_frames) { - FAIL("frame_count: got %" PRIu64 ", want %" PRIu32, got_num_frames, - want_num_frames); - return false; + RETURN_FAIL("frame_count: got %" PRIu64 ", want %" PRIu32, got_num_frames, + want_num_frames); } - // TODO: test calling wuffs_base__image_buffer__loop. - return true; + return NULL; } -void test_wuffs_gif_decode_animated_big() { +const char* test_wuffs_gif_decode_animated_big() { CHECK_FOCUS(__func__); - do_test_wuffs_gif_decode_animated("../../data/gifplayer-muybridge.gif", 0, - 380, NULL); + return do_test_wuffs_gif_decode_animated("../../data/gifplayer-muybridge.gif", + 0, 380, NULL); } -void test_wuffs_gif_decode_animated_medium() { +const char* test_wuffs_gif_decode_animated_medium() { CHECK_FOCUS(__func__); - do_test_wuffs_gif_decode_animated("../../data/muybridge.gif", 0, 15, NULL); + return do_test_wuffs_gif_decode_animated("../../data/muybridge.gif", 0, 15, + NULL); } -void test_wuffs_gif_decode_animated_small() { +const char* test_wuffs_gif_decode_animated_small() { CHECK_FOCUS(__func__); // animated-red-blue.gif's num_loops should be 3. The value explicitly in the // wire format is 0x0002, but that value means "repeat 2 times after the @@ -625,34 +586,33 @@ void test_wuffs_gif_decode_animated_small() { make_rect_ie_u32(15, 0, 64, 40), make_rect_ie_u32(15, 0, 64, 40), }; - do_test_wuffs_gif_decode_animated( + return do_test_wuffs_gif_decode_animated( "../../data/animated-red-blue.gif", want_num_loops, WUFFS_TESTLIB_ARRAY_SIZE(want_frame_config_bounds), want_frame_config_bounds); } -void test_wuffs_gif_decode_frame_out_of_bounds() { +const char* test_wuffs_gif_decode_frame_out_of_bounds() { CHECK_FOCUS(__func__); wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ .data = global_src_slice, }); - if (!read_file(&src, "../../data/artificial/gif-frame-out-of-bounds.gif")) { - return; + const char* z = + read_file(&src, "../../data/artificial/gif-frame-out-of-bounds.gif"); + if (z) { + return z; } wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_base__status z = - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } 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) { - FAIL("decode_image_config: \"%s\"", z); - return; + RETURN_FAIL("decode_image_config: \"%s\"", z); } // The nominal width and height for the overall image is 2×2, but its first @@ -664,28 +624,24 @@ void test_wuffs_gif_decode_frame_out_of_bounds() { const uint32_t height = 2; if (wuffs_base__pixel_config__width(&ic.pixcfg) != width) { - FAIL("width: got %" PRIu32 ", want %" PRIu32, - wuffs_base__pixel_config__width(&ic.pixcfg), width); - return; + RETURN_FAIL("width: got %" PRIu32 ", want %" PRIu32, + wuffs_base__pixel_config__width(&ic.pixcfg), width); } if (wuffs_base__pixel_config__height(&ic.pixcfg) != height) { - FAIL("height: got %" PRIu32 ", want %" PRIu32, - wuffs_base__pixel_config__height(&ic.pixcfg), height); - return; + RETURN_FAIL("height: got %" PRIu32 ", want %" PRIu32, + wuffs_base__pixel_config__height(&ic.pixcfg), height); } 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) { - FAIL("set_from_slice: \"%s\"", z); - return; + RETURN_FAIL("set_from_slice: \"%s\"", z); } uint64_t workbuf_len = wuffs_base__image_config__workbuf_len(&ic).max_incl; if (workbuf_len > BUFFER_SIZE) { - FAIL("work buffer size is too large"); - return; + RETURN_FAIL("work buffer size is too large"); } wuffs_base__slice_u8 workbuf = ((wuffs_base__slice_u8){ .ptr = global_work_array, @@ -716,26 +672,23 @@ void test_wuffs_gif_decode_frame_out_of_bounds() { z = 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) { - FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i, z); - return; + RETURN_FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i, z); } break; } if (z) { - FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i, z); - return; + RETURN_FAIL("decode_frame_config #%" PRIu32 ": got \"%s\"", i, z); } wuffs_base__rect_ie_u32 got = wuffs_base__frame_config__bounds(&fc); wuffs_base__rect_ie_u32 want = want_frame_config_bounds[i]; if (!wuffs_base__rect_ie_u32__equals(&got, want)) { - FAIL("decode_frame_config #%" PRIu32 ": bounds: got (%" PRIu32 - ", %" PRIu32 ")-(%" PRIu32 ", %" PRIu32 "), want (%" PRIu32 - ", %" PRIu32 ")-(%" PRIu32 ", %" PRIu32 ")", - i, got.min_incl_x, got.min_incl_y, got.max_excl_x, got.max_excl_y, - want.min_incl_x, want.min_incl_y, want.max_excl_x, - want.max_excl_y); - return; + RETURN_FAIL("decode_frame_config #%" PRIu32 ": bounds: got (%" PRIu32 + ", %" PRIu32 ")-(%" PRIu32 ", %" PRIu32 "), want (%" PRIu32 + ", %" PRIu32 ")-(%" PRIu32 ", %" PRIu32 ")", + i, got.min_incl_x, got.min_incl_y, got.max_excl_x, + got.max_excl_y, want.min_incl_x, want.min_incl_y, + want.max_excl_x, want.max_excl_y); } } @@ -751,8 +704,7 @@ void test_wuffs_gif_decode_frame_out_of_bounds() { z = wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader, workbuf, NULL); if (z) { - FAIL("decode_frame #%" PRIu32 ": got \"%s\"", i, z); - return; + RETURN_FAIL("decode_frame #%" PRIu32 ": got \"%s\"", i, z); } char got[(width * height) + 1]; @@ -766,90 +718,88 @@ void test_wuffs_gif_decode_frame_out_of_bounds() { const char* want = want_pixel_indexes[i]; if (memcmp(got, want, width * height)) { - FAIL("decode_frame #%" PRIu32 ": got \"%s\", want \"%s\"", i, got, - want); - return; + RETURN_FAIL("decode_frame #%" PRIu32 ": got \"%s\", want \"%s\"", i, + got, want); } } } + return NULL; } -void test_wuffs_gif_decode_input_is_a_gif() { +const char* test_wuffs_gif_decode_input_is_a_gif() { CHECK_FOCUS(__func__); - do_test_wuffs_gif_decode("../../data/bricks-dither.gif", - "../../data/bricks-dither.palette", - "../../data/bricks-dither.indexes", 0); + return do_test_wuffs_gif_decode("../../data/bricks-dither.gif", + "../../data/bricks-dither.palette", + "../../data/bricks-dither.indexes", 0); } -void test_wuffs_gif_decode_input_is_a_gif_many_big_reads() { +const char* test_wuffs_gif_decode_input_is_a_gif_many_big_reads() { CHECK_FOCUS(__func__); - do_test_wuffs_gif_decode("../../data/bricks-dither.gif", - "../../data/bricks-dither.palette", - "../../data/bricks-dither.indexes", 4096); + return do_test_wuffs_gif_decode("../../data/bricks-dither.gif", + "../../data/bricks-dither.palette", + "../../data/bricks-dither.indexes", 4096); } -void test_wuffs_gif_decode_input_is_a_gif_many_medium_reads() { +const char* test_wuffs_gif_decode_input_is_a_gif_many_medium_reads() { CHECK_FOCUS(__func__); - do_test_wuffs_gif_decode("../../data/bricks-dither.gif", - "../../data/bricks-dither.palette", - "../../data/bricks-dither.indexes", 787); + return do_test_wuffs_gif_decode("../../data/bricks-dither.gif", + "../../data/bricks-dither.palette", + "../../data/bricks-dither.indexes", 787); // The magic 787 tickles being in the middle of a decode_extension skip // call. // // TODO: has 787 changed since we decode the image_config separately? } -void test_wuffs_gif_decode_input_is_a_gif_many_small_reads() { +const char* test_wuffs_gif_decode_input_is_a_gif_many_small_reads() { CHECK_FOCUS(__func__); - do_test_wuffs_gif_decode("../../data/bricks-dither.gif", - "../../data/bricks-dither.palette", - "../../data/bricks-dither.indexes", 13); + return do_test_wuffs_gif_decode("../../data/bricks-dither.gif", + "../../data/bricks-dither.palette", + "../../data/bricks-dither.indexes", 13); } -void test_wuffs_gif_decode_input_is_a_png() { +const char* test_wuffs_gif_decode_input_is_a_png() { CHECK_FOCUS(__func__); wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ .data = global_src_slice, }); - if (!read_file(&src, "../../data/bricks-dither.png")) { - return; + const char* z = read_file(&src, "../../data/bricks-dither.png"); + if (z) { + return z; } wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_base__status z = - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } 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) { - FAIL("decode_image_config: got \"%s\", want \"%s\"", z, - wuffs_gif__error__bad_header); - return; + RETURN_FAIL("decode_image_config: got \"%s\", want \"%s\"", z, + wuffs_gif__error__bad_header); } + return NULL; } -bool do_test_wuffs_gif_num_decoded(bool frame_config) { +const char* do_test_wuffs_gif_num_decoded(bool frame_config) { wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ .data = global_src_slice, }); - if (!read_file(&src, "../../data/animated-red-blue.gif")) { - return false; + const char* z = read_file(&src, "../../data/animated-red-blue.gif"); + if (z) { + return z; } wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_base__status z = - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return false; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); @@ -858,15 +808,13 @@ bool do_test_wuffs_gif_num_decoded(bool frame_config) { wuffs_base__image_config ic = ((wuffs_base__image_config){}); z = wuffs_gif__decoder__decode_image_config(&dec, &ic, src_reader); if (z) { - FAIL("decode_image_config: \"%s\"", z); - return false; + RETURN_FAIL("decode_image_config: \"%s\"", z); } z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg, global_pixel_slice); if (z) { - FAIL("set_from_slice: \"%s\"", z); - return false; + RETURN_FAIL("set_from_slice: \"%s\"", z); } } @@ -884,15 +832,14 @@ bool do_test_wuffs_gif_num_decoded(bool frame_config) { ? (uint64_t)(wuffs_gif__decoder__num_decoded_frame_configs(&dec)) : (uint64_t)(wuffs_gif__decoder__num_decoded_frames(&dec)); if (got != want) { - FAIL("num_%ss: got %" PRIu64 ", want %" PRIu64, method, got, want); - return false; + RETURN_FAIL("num_%ss: got %" PRIu64 ", want %" PRIu64, method, got, want); } if (end_of_data) { break; } - wuffs_base__status z = NULL; + const char* z = NULL; if (frame_config) { z = wuffs_gif__decoder__decode_frame_config(&dec, NULL, src_reader); } else { @@ -902,54 +849,49 @@ bool do_test_wuffs_gif_num_decoded(bool frame_config) { if (!z) { want++; - continue; } else if (z == wuffs_base__warning__end_of_data) { end_of_data = true; - continue; + } else { + RETURN_FAIL("%s: \"%s\"", method, z); } - FAIL("%s: \"%s\"", method, z); - return false; } if (want != 4) { - FAIL("%s: got %" PRIu64 ", want 4", method, want); - return false; + RETURN_FAIL("%s: got %" PRIu64 ", want 4", method, want); } - return true; + return NULL; } -void test_wuffs_gif_num_decoded_frame_configs() { +const char* test_wuffs_gif_num_decoded_frame_configs() { CHECK_FOCUS(__func__); - do_test_wuffs_gif_num_decoded(true); + return do_test_wuffs_gif_num_decoded(true); } -void test_wuffs_gif_num_decoded_frames() { +const char* test_wuffs_gif_num_decoded_frames() { CHECK_FOCUS(__func__); - do_test_wuffs_gif_num_decoded(false); + return do_test_wuffs_gif_num_decoded(false); } -bool do_test_wuffs_gif_io_position(bool chunked) { +const char* do_test_wuffs_gif_io_position(bool chunked) { wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ .data = global_src_slice, }); - if (!read_file(&src, "../../data/animated-red-blue.gif")) { - return false; + const char* z = read_file(&src, "../../data/animated-red-blue.gif"); + if (z) { + return z; } wuffs_gif__decoder dec = ((wuffs_gif__decoder){}); - wuffs_base__status z = - wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + z = wuffs_gif__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return false; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); if (chunked) { if (src.meta.wi < 50) { - FAIL("src is too short"); - return false; + RETURN_FAIL("src is too short"); } size_t saved_wi = src.meta.wi; bool saved_closed = src.meta.closed; @@ -958,28 +900,24 @@ bool do_test_wuffs_gif_io_position(bool chunked) { z = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader); if (z != wuffs_base__suspension__short_read) { - FAIL("decode_image_config (chunked): \"%s\"", z); - return false; + RETURN_FAIL("decode_image_config (chunked): \"%s\"", z); } src.meta.wi = saved_wi; src.meta.closed = saved_closed; if (src.meta.pos != 0) { - FAIL("src.meta.pos: got %" PRIu64 ", want zero", src.meta.pos); - return false; + RETURN_FAIL("src.meta.pos: got %" PRIu64 ", want zero", src.meta.pos); } wuffs_base__io_buffer__compact(&src); if (src.meta.pos == 0) { - FAIL("src.meta.pos: got %" PRIu64 ", want non-zero", src.meta.pos); - return false; + RETURN_FAIL("src.meta.pos: got %" PRIu64 ", want non-zero", src.meta.pos); } } z = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader); if (z) { - FAIL("decode_image_config: \"%s\"", z); - return false; + RETURN_FAIL("decode_image_config: \"%s\"", z); } wuffs_base__frame_config fcs[4]; @@ -990,64 +928,59 @@ bool do_test_wuffs_gif_io_position(bool chunked) { fcs[i] = ((wuffs_base__frame_config){}); z = wuffs_gif__decoder__decode_frame_config(&dec, &fcs[i], src_reader); if (z) { - FAIL("decode_frame_config #%d: \"%s\"", i, z); - return false; + RETURN_FAIL("decode_frame_config #%d: \"%s\"", i, z); } uint64_t index_got = wuffs_base__frame_config__index(&fcs[i]); uint64_t index_want = i; if (index_got != index_want) { - FAIL("index #%d: got %" PRIu64 ", want %" PRIu64, i, index_got, - index_want); - return false; + RETURN_FAIL("index #%d: got %" PRIu64 ", want %" PRIu64, i, index_got, + index_want); } uint32_t width_got = wuffs_base__frame_config__width(&fcs[i]); uint32_t width_want = width_wants[i]; if (width_got != width_want) { - FAIL("width #%d: got %" PRIu32 ", want %" PRIu32, i, width_got, - width_want); - return false; + RETURN_FAIL("width #%d: got %" PRIu32 ", want %" PRIu32, i, width_got, + width_want); } uint64_t pos_got = wuffs_base__frame_config__io_position(&fcs[i]); uint64_t pos_want = pos_wants[i]; if (pos_got != pos_want) { - FAIL("io_position #%d: got %" PRIu64 ", want %" PRIu64, i, pos_got, - pos_want); - return false; + RETURN_FAIL("io_position #%d: got %" PRIu64 ", want %" PRIu64, i, pos_got, + pos_want); } // Look for the 0x21 byte that's a GIF's Extension Introducer. Not every // GIF's frame_config's I/O position will point to 0x21, as an 0x2C Image // Separator is also valid. But for animated-red-blue.gif, it'll be 0x21. if (pos_got < src.meta.pos) { - FAIL("io_position #%d: got %" PRIu64 ", was too small", i, pos_got); - return false; + RETURN_FAIL("io_position #%d: got %" PRIu64 ", was too small", i, + pos_got); } uint64_t src_ptr_offset = pos_got - src.meta.pos; if (src_ptr_offset >= src.meta.wi) { - FAIL("io_position #%d: got %" PRIu64 ", was too large", i, pos_got); - return false; + RETURN_FAIL("io_position #%d: got %" PRIu64 ", was too large", i, + pos_got); } uint8_t x = src.data.ptr[src_ptr_offset]; if (x != 0x21) { - FAIL("Image Descriptor byte #%d: got 0x%02X, want 0x2C", i, (int)x); - return false; + RETURN_FAIL("Image Descriptor byte #%d: got 0x%02X, want 0x2C", i, + (int)x); } } z = wuffs_gif__decoder__decode_frame_config(&dec, NULL, src_reader); if (z != wuffs_base__warning__end_of_data) { - FAIL("decode_frame_config EOD: \"%s\"", z); - return false; + RETURN_FAIL("decode_frame_config EOD: \"%s\"", z); } // If we're chunked, we've discarded some source bytes due to an earlier // wuffs_base__io_buffer__compact call. We won't bother testing // wuffs_gif__decoder__restart_frame in that case. if (chunked) { - return true; + return NULL; } for (i = 0; i < 4; i++) { @@ -1056,8 +989,7 @@ bool do_test_wuffs_gif_io_position(bool chunked) { z = wuffs_gif__decoder__restart_frame( &dec, i, wuffs_base__frame_config__io_position(&fcs[i])); if (z) { - FAIL("restart_frame #%d: \"%s\"", i, z); - return false; + RETURN_FAIL("restart_frame #%d: \"%s\"", i, z); } int j; @@ -1065,157 +997,153 @@ bool do_test_wuffs_gif_io_position(bool chunked) { wuffs_base__frame_config fc = ((wuffs_base__frame_config){}); z = wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader); if (z) { - FAIL("decode_frame_config #%d, #%d: \"%s\"", i, j, z); - return false; + RETURN_FAIL("decode_frame_config #%d, #%d: \"%s\"", i, j, z); } uint64_t index_got = wuffs_base__frame_config__index(&fc); uint64_t index_want = j; if (index_got != index_want) { - FAIL("index #%d, #%d: got %" PRIu64 ", want %" PRIu64, i, j, index_got, - index_want); - return false; + RETURN_FAIL("index #%d, #%d: got %" PRIu64 ", want %" PRIu64, i, j, + index_got, index_want); } uint32_t width_got = wuffs_base__frame_config__width(&fc); uint32_t width_want = width_wants[j]; if (width_got != width_want) { - FAIL("width #%d, #%d: got %" PRIu32 ", want %" PRIu32, i, j, width_got, - width_want); - return false; + RETURN_FAIL("width #%d, #%d: got %" PRIu32 ", want %" PRIu32, i, j, + width_got, width_want); } } z = wuffs_gif__decoder__decode_frame_config(&dec, NULL, src_reader); if (z != wuffs_base__warning__end_of_data) { - FAIL("decode_frame_config EOD #%d: \"%s\"", i, z); - return false; + RETURN_FAIL("decode_frame_config EOD #%d: \"%s\"", i, z); } } - return true; + return NULL; } -void test_wuffs_gif_io_position_one_chunk() { +const char* test_wuffs_gif_io_position_one_chunk() { CHECK_FOCUS(__func__); - do_test_wuffs_gif_io_position(false); + return do_test_wuffs_gif_io_position(false); } -void test_wuffs_gif_io_position_two_chunks() { +const char* test_wuffs_gif_io_position_two_chunks() { CHECK_FOCUS(__func__); - do_test_wuffs_gif_io_position(true); + return do_test_wuffs_gif_io_position(true); } // ---------------- Mimic Tests #ifdef WUFFS_MIMIC -bool do_test_mimic_gif_decode(const char* filename) { +const char* do_test_mimic_gif_decode(const char* filename) { wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ .data = global_src_slice, }); - if (!read_file(&src, filename)) { - return false; + const char* z = read_file(&src, filename); + if (z) { + return z; } src.meta.ri = 0; wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ .data = global_got_slice, }); - const char* got_msg = wuffs_gif_decode(&got, &src); - if (got_msg) { - FAIL("%s", got_msg); - return false; + z = wuffs_gif_decode(&got, &src); + if (z) { + return z; } src.meta.ri = 0; wuffs_base__io_buffer want = ((wuffs_base__io_buffer){ .data = global_want_slice, }); - const char* want_msg = mimic_gif_decode(&want, &src); - if (want_msg) { - FAIL("%s", want_msg); - return false; + z = mimic_gif_decode(&want, &src); + if (z) { + return z; } - if (!io_buffers_equal("", &got, &want)) { - return false; + z = check_io_buffers_equal("", &got, &want); + if (z) { + return z; } // TODO: check the palette RGB values, not just the palette indexes // (pixels). - return true; + return NULL; } -void test_mimic_gif_decode_animated_small() { +const char* test_mimic_gif_decode_animated_small() { CHECK_FOCUS(__func__); - do_test_mimic_gif_decode("../../data/animated-red-blue.gif"); + return do_test_mimic_gif_decode("../../data/animated-red-blue.gif"); } -void test_mimic_gif_decode_bricks_dither() { +const char* test_mimic_gif_decode_bricks_dither() { CHECK_FOCUS(__func__); - do_test_mimic_gif_decode("../../data/bricks-dither.gif"); + return do_test_mimic_gif_decode("../../data/bricks-dither.gif"); } -void test_mimic_gif_decode_bricks_gray() { +const char* test_mimic_gif_decode_bricks_gray() { CHECK_FOCUS(__func__); - do_test_mimic_gif_decode("../../data/bricks-gray.gif"); + return do_test_mimic_gif_decode("../../data/bricks-gray.gif"); } -void test_mimic_gif_decode_bricks_nodither() { +const char* test_mimic_gif_decode_bricks_nodither() { CHECK_FOCUS(__func__); - do_test_mimic_gif_decode("../../data/bricks-nodither.gif"); + return do_test_mimic_gif_decode("../../data/bricks-nodither.gif"); } -void test_mimic_gif_decode_gifplayer_muybridge() { +const char* test_mimic_gif_decode_gifplayer_muybridge() { CHECK_FOCUS(__func__); - do_test_mimic_gif_decode("../../data/gifplayer-muybridge.gif"); + return do_test_mimic_gif_decode("../../data/gifplayer-muybridge.gif"); } -void test_mimic_gif_decode_harvesters() { +const char* test_mimic_gif_decode_harvesters() { CHECK_FOCUS(__func__); - do_test_mimic_gif_decode("../../data/harvesters.gif"); + return do_test_mimic_gif_decode("../../data/harvesters.gif"); } -void test_mimic_gif_decode_hat() { +const char* test_mimic_gif_decode_hat() { CHECK_FOCUS(__func__); - do_test_mimic_gif_decode("../../data/hat.gif"); + return do_test_mimic_gif_decode("../../data/hat.gif"); } -void test_mimic_gif_decode_hibiscus() { +const char* test_mimic_gif_decode_hibiscus() { CHECK_FOCUS(__func__); - do_test_mimic_gif_decode("../../data/hibiscus.gif"); + return do_test_mimic_gif_decode("../../data/hibiscus.gif"); } -void test_mimic_gif_decode_hippopotamus_interlaced() { +const char* test_mimic_gif_decode_hippopotamus_interlaced() { CHECK_FOCUS(__func__); - do_test_mimic_gif_decode("../../data/hippopotamus.interlaced.gif"); + return do_test_mimic_gif_decode("../../data/hippopotamus.interlaced.gif"); } -void test_mimic_gif_decode_hippopotamus_regular() { +const char* test_mimic_gif_decode_hippopotamus_regular() { CHECK_FOCUS(__func__); - do_test_mimic_gif_decode("../../data/hippopotamus.regular.gif"); + return do_test_mimic_gif_decode("../../data/hippopotamus.regular.gif"); } -void test_mimic_gif_decode_muybridge() { +const char* test_mimic_gif_decode_muybridge() { CHECK_FOCUS(__func__); - do_test_mimic_gif_decode("../../data/muybridge.gif"); + return do_test_mimic_gif_decode("../../data/muybridge.gif"); } -void test_mimic_gif_decode_pjw_thumbnail() { +const char* test_mimic_gif_decode_pjw_thumbnail() { CHECK_FOCUS(__func__); - do_test_mimic_gif_decode("../../data/pjw-thumbnail.gif"); + return do_test_mimic_gif_decode("../../data/pjw-thumbnail.gif"); } #endif // WUFFS_MIMIC // ---------------- GIF Benches -bool do_bench_gif_decode(const char* (*decode_func)(wuffs_base__io_buffer*, - wuffs_base__io_buffer*), - const char* filename, - uint64_t iters_unscaled) { +const char* do_bench_gif_decode( + const char* (*decode_func)(wuffs_base__io_buffer*, wuffs_base__io_buffer*), + const char* filename, + uint64_t iters_unscaled) { wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ .data = global_got_slice, }); @@ -1223,8 +1151,9 @@ bool do_bench_gif_decode(const char* (*decode_func)(wuffs_base__io_buffer*, .data = global_src_slice, }); - if (!read_file(&src, filename)) { - return false; + const char* z = read_file(&src, filename); + if (z) { + return z; } bench_start(); @@ -1234,71 +1163,72 @@ bool do_bench_gif_decode(const char* (*decode_func)(wuffs_base__io_buffer*, for (i = 0; i < iters; i++) { got.meta.wi = 0; src.meta.ri = 0; - const char* error_msg = decode_func(&got, &src); - if (error_msg) { - FAIL("%s", error_msg); - return false; + z = decode_func(&got, &src); + if (z) { + return z; } n_bytes += got.meta.wi; } bench_finish(iters, n_bytes); - return true; + return NULL; } -void bench_wuffs_gif_decode_1k_bw() { +const char* bench_wuffs_gif_decode_1k_bw() { CHECK_FOCUS(__func__); - do_bench_gif_decode(wuffs_gif_decode, "../../data/pjw-thumbnail.gif", 2000); + return do_bench_gif_decode(wuffs_gif_decode, "../../data/pjw-thumbnail.gif", + 2000); } -void bench_wuffs_gif_decode_1k_color() { +const char* bench_wuffs_gif_decode_1k_color() { CHECK_FOCUS(__func__); - do_bench_gif_decode(wuffs_gif_decode, "../../data/hippopotamus.regular.gif", - 1000); + return do_bench_gif_decode(wuffs_gif_decode, + "../../data/hippopotamus.regular.gif", 1000); } -void bench_wuffs_gif_decode_10k() { +const char* bench_wuffs_gif_decode_10k() { CHECK_FOCUS(__func__); - do_bench_gif_decode(wuffs_gif_decode, "../../data/hat.gif", 100); + return do_bench_gif_decode(wuffs_gif_decode, "../../data/hat.gif", 100); } -void bench_wuffs_gif_decode_100k() { +const char* bench_wuffs_gif_decode_100k() { CHECK_FOCUS(__func__); - do_bench_gif_decode(wuffs_gif_decode, "../../data/hibiscus.gif", 10); + return do_bench_gif_decode(wuffs_gif_decode, "../../data/hibiscus.gif", 10); } -void bench_wuffs_gif_decode_1000k() { +const char* bench_wuffs_gif_decode_1000k() { CHECK_FOCUS(__func__); - do_bench_gif_decode(wuffs_gif_decode, "../../data/harvesters.gif", 1); + return do_bench_gif_decode(wuffs_gif_decode, "../../data/harvesters.gif", 1); } // ---------------- Mimic Benches #ifdef WUFFS_MIMIC -void bench_mimic_gif_decode_1k_bw() { +const char* bench_mimic_gif_decode_1k_bw() { CHECK_FOCUS(__func__); - do_bench_gif_decode(mimic_gif_decode, "../../data/pjw-thumbnail.gif", 2000); + return do_bench_gif_decode(mimic_gif_decode, "../../data/pjw-thumbnail.gif", + 2000); } -void bench_mimic_gif_decode_1k_color() { +const char* bench_mimic_gif_decode_1k_color() { CHECK_FOCUS(__func__); - do_bench_gif_decode(mimic_gif_decode, "../../data/hippopotamus.regular.gif", - 1000); + return do_bench_gif_decode(mimic_gif_decode, + "../../data/hippopotamus.regular.gif", 1000); } -void bench_mimic_gif_decode_10k() { +const char* bench_mimic_gif_decode_10k() { CHECK_FOCUS(__func__); - do_bench_gif_decode(mimic_gif_decode, "../../data/hat.gif", 100); + return do_bench_gif_decode(mimic_gif_decode, "../../data/hat.gif", 100); } -void bench_mimic_gif_decode_100k() { +const char* bench_mimic_gif_decode_100k() { CHECK_FOCUS(__func__); - do_bench_gif_decode(mimic_gif_decode, "../../data/hibiscus.gif", 10); + return do_bench_gif_decode(mimic_gif_decode, "../../data/hibiscus.gif", 10); } -void bench_mimic_gif_decode_1000k() { +const char* bench_mimic_gif_decode_1000k() { CHECK_FOCUS(__func__); - do_bench_gif_decode(mimic_gif_decode, "../../data/harvesters.gif", 1); + return do_bench_gif_decode(mimic_gif_decode, "../../data/harvesters.gif", 1); } #endif // WUFFS_MIMIC diff --git a/test/c/std/gzip.c b/test/c/std/gzip.c index 09946e7e..c1513d3f 100644 --- a/test/c/std/gzip.c +++ b/test/c/std/gzip.c @@ -86,7 +86,7 @@ const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst, uint64_t wlimit, uint64_t rlimit) { wuffs_gzip__decoder dec = ((wuffs_gzip__decoder){}); - wuffs_base__status z = + const char* z = wuffs_gzip__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); if (z) { return z; @@ -102,8 +102,7 @@ const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst, set_reader_limit(&src_reader, rlimit); } - wuffs_base__status z = - wuffs_gzip__decoder__decode(&dec, dst_writer, src_reader); + z = wuffs_gzip__decoder__decode(&dec, dst_writer, src_reader); if ((wlimit && (z == wuffs_base__suspension__short_write)) || (rlimit && (z == wuffs_base__suspension__short_read))) { @@ -113,7 +112,8 @@ const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst, } } -bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) { +const char* do_test_wuffs_gzip_checksum(bool ignore_checksum, + uint32_t bad_checksum) { wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ .data = global_got_slice, }); @@ -121,14 +121,14 @@ bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) { .data = global_src_slice, }); - if (!read_file(&src, gzip_midsummer_gt.src_filename)) { - return false; + const char* z = read_file(&src, gzip_midsummer_gt.src_filename); + if (z) { + return z; } // Flip a bit in the gzip checksum, which is in the last 8 bytes of the file. if (src.meta.wi < 8) { - FAIL("source file was too short"); - return false; + RETURN_FAIL("source file was too short"); } if (bad_checksum) { src.data.ptr[src.meta.wi - 1 - (bad_checksum & 7)] ^= 1; @@ -137,11 +137,10 @@ bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) { int end_limit; for (end_limit = 0; end_limit < 10; end_limit++) { wuffs_gzip__decoder dec = ((wuffs_gzip__decoder){}); - wuffs_base__status z = wuffs_gzip__decoder__check_wuffs_version( - &dec, sizeof dec, WUFFS_VERSION); + z = wuffs_gzip__decoder__check_wuffs_version(&dec, sizeof dec, + WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return false; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } wuffs_gzip__decoder__set_ignore_checksum(&dec, ignore_checksum); got.meta.wi = 0; @@ -159,8 +158,7 @@ bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) { continue; } if (src.meta.wi < end_limit) { - FAIL("end_limit=%d: not enough source data", end_limit); - return false; + RETURN_FAIL("end_limit=%d: not enough source data", end_limit); } set_reader_limit(&src_reader, src.meta.wi - (uint64_t)(end_limit)); want_z = wuffs_base__suspension__short_read; @@ -170,87 +168,89 @@ bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) { : NULL; } - wuffs_base__status got_z = + const char* got_z = wuffs_gzip__decoder__decode(&dec, got_writer, src_reader); if (got_z != want_z) { - FAIL("end_limit=%d: got \"%s\", want \"%s\"", end_limit, got_z, want_z); - return false; + RETURN_FAIL("end_limit=%d: got \"%s\", want \"%s\"", end_limit, got_z, + want_z); } } } - return true; + return NULL; } -void test_wuffs_gzip_checksum_ignore() { +const char* test_wuffs_gzip_checksum_ignore() { CHECK_FOCUS(__func__); - do_test_wuffs_gzip_checksum(true, 1); + return do_test_wuffs_gzip_checksum(true, 8 | 0); } -void test_wuffs_gzip_checksum_verify_bad1() { +const char* test_wuffs_gzip_checksum_verify_bad0() { CHECK_FOCUS(__func__); - do_test_wuffs_gzip_checksum(false, 1); + return do_test_wuffs_gzip_checksum(false, 8 | 0); } -void test_wuffs_gzip_checksum_verify_bad7() { +const char* test_wuffs_gzip_checksum_verify_bad7() { CHECK_FOCUS(__func__); - do_test_wuffs_gzip_checksum(false, 7); + return do_test_wuffs_gzip_checksum(false, 8 | 7); } -void test_wuffs_gzip_checksum_verify_good() { +const char* test_wuffs_gzip_checksum_verify_good() { CHECK_FOCUS(__func__); - do_test_wuffs_gzip_checksum(false, 0); + return do_test_wuffs_gzip_checksum(false, 0); } -void test_wuffs_gzip_decode_midsummer() { +const char* test_wuffs_gzip_decode_midsummer() { CHECK_FOCUS(__func__); - do_test_io_buffers(wuffs_gzip_decode, &gzip_midsummer_gt, 0, 0); + return do_test_io_buffers(wuffs_gzip_decode, &gzip_midsummer_gt, 0, 0); } -void test_wuffs_gzip_decode_pi() { +const char* test_wuffs_gzip_decode_pi() { CHECK_FOCUS(__func__); - do_test_io_buffers(wuffs_gzip_decode, &gzip_pi_gt, 0, 0); + return do_test_io_buffers(wuffs_gzip_decode, &gzip_pi_gt, 0, 0); } // ---------------- Mimic Tests #ifdef WUFFS_MIMIC -void test_mimic_gzip_decode_midsummer() { +const char* test_mimic_gzip_decode_midsummer() { CHECK_FOCUS(__func__); - do_test_io_buffers(mimic_gzip_decode, &gzip_midsummer_gt, 0, 0); + return do_test_io_buffers(mimic_gzip_decode, &gzip_midsummer_gt, 0, 0); } -void test_mimic_gzip_decode_pi() { +const char* test_mimic_gzip_decode_pi() { CHECK_FOCUS(__func__); - do_test_io_buffers(mimic_gzip_decode, &gzip_pi_gt, 0, 0); + return do_test_io_buffers(mimic_gzip_decode, &gzip_pi_gt, 0, 0); } #endif // WUFFS_MIMIC // ---------------- Gzip Benches -void bench_wuffs_gzip_decode_10k() { +const char* bench_wuffs_gzip_decode_10k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(wuffs_gzip_decode, tc_dst, &gzip_midsummer_gt, 0, 0, 300); + return do_bench_io_buffers(wuffs_gzip_decode, tc_dst, &gzip_midsummer_gt, 0, + 0, 300); } -void bench_wuffs_gzip_decode_100k() { +const char* bench_wuffs_gzip_decode_100k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(wuffs_gzip_decode, tc_dst, &gzip_pi_gt, 0, 0, 30); + return do_bench_io_buffers(wuffs_gzip_decode, tc_dst, &gzip_pi_gt, 0, 0, 30); } // ---------------- Mimic Benches #ifdef WUFFS_MIMIC -void bench_mimic_gzip_decode_10k() { +const char* bench_mimic_gzip_decode_10k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(mimic_gzip_decode, tc_dst, &gzip_midsummer_gt, 0, 0, 300); + return do_bench_io_buffers(mimic_gzip_decode, tc_dst, &gzip_midsummer_gt, 0, + 0, 300); } -void bench_mimic_gzip_decode_100k() { +const char* bench_mimic_gzip_decode_100k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(mimic_gzip_decode, tc_dst, &gzip_pi_gt, 0, 0, 30); + return do_bench_io_buffers(mimic_gzip_decode, tc_dst, &gzip_pi_gt, 0, 0, 30); } #endif // WUFFS_MIMIC @@ -264,7 +264,7 @@ void bench_mimic_gzip_decode_100k() { proc tests[] = { test_wuffs_gzip_checksum_ignore, // - test_wuffs_gzip_checksum_verify_bad1, // + test_wuffs_gzip_checksum_verify_bad0, // test_wuffs_gzip_checksum_verify_bad7, // test_wuffs_gzip_checksum_verify_good, // test_wuffs_gzip_decode_midsummer, // diff --git a/test/c/std/lzw.c b/test/c/std/lzw.c index 8a69b038..838298bd 100644 --- a/test/c/std/lzw.c +++ b/test/c/std/lzw.c @@ -64,12 +64,12 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the // ---------------- LZW Tests -bool do_test_wuffs_lzw_decode(const char* src_filename, - uint64_t src_size, - const char* want_filename, - uint64_t want_size, - uint64_t wlimit, - uint64_t rlimit) { +const char* do_test_wuffs_lzw_decode(const char* src_filename, + uint64_t src_size, + const char* want_filename, + uint64_t want_size, + uint64_t wlimit, + uint64_t rlimit) { wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ .data = global_got_slice, }); @@ -80,35 +80,35 @@ bool do_test_wuffs_lzw_decode(const char* src_filename, .data = global_src_slice, }); - if (!read_file(&src, src_filename)) { - return false; + const char* z = read_file(&src, src_filename); + if (z) { + return z; } if (src.meta.wi != src_size) { - FAIL("src size: got %d, want %d", (int)(src.meta.wi), (int)(src_size)); - return false; + RETURN_FAIL("src size: got %d, want %d", (int)(src.meta.wi), + (int)(src_size)); } // The first byte in that file, the LZW literal width, should be 0x08. uint8_t literal_width = src.data.ptr[0]; if (literal_width != 0x08) { - FAIL("LZW literal width: got %d, want %d", (int)(src.data.ptr[0]), 0x08); - return false; + RETURN_FAIL("LZW literal width: got %d, want %d", (int)(src.data.ptr[0]), + 0x08); } src.meta.ri++; - if (!read_file(&want, want_filename)) { - return false; + z = read_file(&want, want_filename); + if (z) { + return z; } if (want.meta.wi != want_size) { - FAIL("want size: got %d, want %d", (int)(want.meta.wi), (int)(want_size)); - return false; + RETURN_FAIL("want size: got %d, want %d", (int)(want.meta.wi), + (int)(want_size)); } wuffs_lzw__decoder dec = ((wuffs_lzw__decoder){}); - wuffs_base__status z = - wuffs_lzw__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); + z = wuffs_lzw__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return false; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } wuffs_lzw__decoder__set_literal_width(&dec, literal_width); int num_iters = 0; @@ -128,81 +128,79 @@ bool do_test_wuffs_lzw_decode(const char* src_filename, z = wuffs_lzw__decoder__decode(&dec, got_writer, src_reader); if (!z) { if (src.meta.ri != src.meta.wi) { - FAIL("decode returned \"ok\" but src was not exhausted"); - return false; + RETURN_FAIL("decode returned \"ok\" but src was not exhausted"); } break; } if ((z != wuffs_base__suspension__short_read) && (z != wuffs_base__suspension__short_write)) { - FAIL("decode: got \"%s\", want \"%s\" or \"%s\"", z, - wuffs_base__suspension__short_read, - wuffs_base__suspension__short_write); - return false; + RETURN_FAIL("decode: got \"%s\", want \"%s\" or \"%s\"", z, + wuffs_base__suspension__short_read, + wuffs_base__suspension__short_write); } if (got.meta.wi < old_wi) { - FAIL("write index got.wi went backwards"); - return false; + RETURN_FAIL("write index got.wi went backwards"); } if (src.meta.ri < old_ri) { - FAIL("read index src.ri went backwards"); - return false; + RETURN_FAIL("read index src.ri went backwards"); } if ((got.meta.wi == old_wi) && (src.meta.ri == old_ri)) { - FAIL("no progress was made"); - return false; + RETURN_FAIL("no progress was made"); } } if (wlimit || rlimit) { if (num_iters <= 1) { - FAIL("num_iters: got %d, want > 1", num_iters); - return false; + RETURN_FAIL("num_iters: got %d, want > 1", num_iters); } } else { if (num_iters != 1) { - FAIL("num_iters: got %d, want 1", num_iters); - return false; + RETURN_FAIL("num_iters: got %d, want 1", num_iters); } } - return io_buffers_equal("", &got, &want); + return check_io_buffers_equal("", &got, &want); } -void test_wuffs_lzw_decode_many_big_reads() { +const char* test_wuffs_lzw_decode_many_big_reads() { CHECK_FOCUS(__func__); - do_test_wuffs_lzw_decode("../../data/bricks-gray.indexes.giflzw", 14731, - "../../data/bricks-gray.indexes", 19200, 0, 4096); + return do_test_wuffs_lzw_decode("../../data/bricks-gray.indexes.giflzw", + 14731, "../../data/bricks-gray.indexes", + 19200, 0, 4096); } -void test_wuffs_lzw_decode_many_small_writes_reads() { +const char* test_wuffs_lzw_decode_many_small_writes_reads() { CHECK_FOCUS(__func__); - do_test_wuffs_lzw_decode("../../data/bricks-gray.indexes.giflzw", 14731, - "../../data/bricks-gray.indexes", 19200, 41, 43); + return do_test_wuffs_lzw_decode("../../data/bricks-gray.indexes.giflzw", + 14731, "../../data/bricks-gray.indexes", + 19200, 41, 43); } -void test_wuffs_lzw_decode_bricks_dither() { +const char* test_wuffs_lzw_decode_bricks_dither() { CHECK_FOCUS(__func__); - do_test_wuffs_lzw_decode("../../data/bricks-dither.indexes.giflzw", 14923, - "../../data/bricks-dither.indexes", 19200, 0, 0); + return do_test_wuffs_lzw_decode("../../data/bricks-dither.indexes.giflzw", + 14923, "../../data/bricks-dither.indexes", + 19200, 0, 0); } -void test_wuffs_lzw_decode_bricks_nodither() { +const char* test_wuffs_lzw_decode_bricks_nodither() { CHECK_FOCUS(__func__); - do_test_wuffs_lzw_decode("../../data/bricks-nodither.indexes.giflzw", 13382, - "../../data/bricks-nodither.indexes", 19200, 0, 0); + return do_test_wuffs_lzw_decode("../../data/bricks-nodither.indexes.giflzw", + 13382, "../../data/bricks-nodither.indexes", + 19200, 0, 0); } -void test_wuffs_lzw_decode_pi() { +const char* test_wuffs_lzw_decode_pi() { CHECK_FOCUS(__func__); - do_test_wuffs_lzw_decode("../../data/pi.txt.giflzw", 50550, - "../../data/pi.txt", 100003, 0, 0); + return do_test_wuffs_lzw_decode("../../data/pi.txt.giflzw", 50550, + "../../data/pi.txt", 100003, 0, 0); } // ---------------- LZW Benches -bool do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) { +const char* do_bench_wuffs_lzw_decode(const char* filename, + uint64_t iters_unscaled) { wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ .data = global_got_slice, }); @@ -212,17 +210,17 @@ bool do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) { wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got); wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); - if (!read_file(&src, filename)) { - return false; + const char* z = read_file(&src, filename); + if (z) { + return z; } if (src.meta.wi <= 0) { - FAIL("src size: got %d, want > 0", (int)(src.meta.wi)); - return false; + RETURN_FAIL("src size: got %d, want > 0", (int)(src.meta.wi)); } uint8_t literal_width = src.data.ptr[0]; if (literal_width != 0x08) { - FAIL("LZW literal width: got %d, want %d", (int)(src.data.ptr[0]), 0x08); - return false; + RETURN_FAIL("LZW literal width: got %d, want %d", (int)(src.data.ptr[0]), + 0x08); } bench_start(); @@ -233,31 +231,29 @@ bool do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) { got.meta.wi = 0; src.meta.ri = 1; // Skip the literal width. wuffs_lzw__decoder dec = ((wuffs_lzw__decoder){}); - wuffs_base__status z = wuffs_lzw__decoder__check_wuffs_version( - &dec, sizeof dec, WUFFS_VERSION); + z = wuffs_lzw__decoder__check_wuffs_version(&dec, sizeof dec, + WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return false; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } z = wuffs_lzw__decoder__decode(&dec, got_writer, src_reader); if (z) { - FAIL("decode: \"%s\"", z); - return false; + RETURN_FAIL("decode: \"%s\"", z); } n_bytes += got.meta.wi; } bench_finish(iters, n_bytes); - return true; + return NULL; } -void bench_wuffs_lzw_decode_20k() { +const char* bench_wuffs_lzw_decode_20k() { CHECK_FOCUS(__func__); - do_bench_wuffs_lzw_decode("../../data/bricks-gray.indexes.giflzw", 50); + return do_bench_wuffs_lzw_decode("../../data/bricks-gray.indexes.giflzw", 50); } -void bench_wuffs_lzw_decode_100k() { +const char* bench_wuffs_lzw_decode_100k() { CHECK_FOCUS(__func__); - do_bench_wuffs_lzw_decode("../../data/pi.txt.giflzw", 10); + return do_bench_wuffs_lzw_decode("../../data/pi.txt.giflzw", 10); } // ---------------- Manifest diff --git a/test/c/std/zlib.c b/test/c/std/zlib.c index 46625266..3c4d374b 100644 --- a/test/c/std/zlib.c +++ b/test/c/std/zlib.c @@ -86,7 +86,7 @@ const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst, uint64_t wlimit, uint64_t rlimit) { wuffs_zlib__decoder dec = ((wuffs_zlib__decoder){}); - wuffs_base__status z = + const char* z = wuffs_zlib__decoder__check_wuffs_version(&dec, sizeof dec, WUFFS_VERSION); if (z) { return z; @@ -102,8 +102,7 @@ const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst, set_reader_limit(&src_reader, rlimit); } - wuffs_base__status z = - wuffs_zlib__decoder__decode(&dec, dst_writer, src_reader); + z = wuffs_zlib__decoder__decode(&dec, dst_writer, src_reader); if ((wlimit && (z == wuffs_base__suspension__short_write)) || (rlimit && (z == wuffs_base__suspension__short_read))) { @@ -113,7 +112,8 @@ const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst, } } -bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) { +const char* do_test_wuffs_zlib_checksum(bool ignore_checksum, + uint32_t bad_checksum) { wuffs_base__io_buffer got = ((wuffs_base__io_buffer){ .data = global_got_slice, }); @@ -121,13 +121,13 @@ bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) { .data = global_src_slice, }); - if (!read_file(&src, zlib_midsummer_gt.src_filename)) { - return false; + const char* z = read_file(&src, zlib_midsummer_gt.src_filename); + if (z) { + return z; } // Flip a bit in the zlib checksum, which is in the last 4 bytes of the file. if (src.meta.wi < 4) { - FAIL("source file was too short"); - return false; + RETURN_FAIL("source file was too short"); } if (bad_checksum) { src.data.ptr[src.meta.wi - 1 - (bad_checksum & 3)] ^= 1; @@ -136,11 +136,10 @@ bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) { int end_limit; for (end_limit = 0; end_limit < 10; end_limit++) { wuffs_zlib__decoder dec = ((wuffs_zlib__decoder){}); - wuffs_base__status z = wuffs_zlib__decoder__check_wuffs_version( - &dec, sizeof dec, WUFFS_VERSION); + z = wuffs_zlib__decoder__check_wuffs_version(&dec, sizeof dec, + WUFFS_VERSION); if (z) { - FAIL("check_wuffs_version: \"%s\"", z); - return false; + RETURN_FAIL("check_wuffs_version: \"%s\"", z); } wuffs_zlib__decoder__set_ignore_checksum(&dec, ignore_checksum); got.meta.wi = 0; @@ -158,8 +157,7 @@ bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) { continue; } if (src.meta.wi < end_limit) { - FAIL("end_limit=%d: not enough source data", end_limit); - return false; + RETURN_FAIL("end_limit=%d: not enough source data", end_limit); } set_reader_limit(&src_reader, src.meta.wi - (uint64_t)(end_limit)); want_z = wuffs_base__suspension__short_read; @@ -169,82 +167,89 @@ bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) { : NULL; } - wuffs_base__status got_z = + const char* got_z = wuffs_zlib__decoder__decode(&dec, got_writer, src_reader); if (got_z != want_z) { - FAIL("end_limit=%d: got \"%s\", want \"%s\"", end_limit, got_z, want_z); - return false; + RETURN_FAIL("end_limit=%d: got \"%s\", want \"%s\"", end_limit, got_z, + want_z); } } } - return true; + return NULL; } -void test_wuffs_zlib_checksum_ignore() { +const char* test_wuffs_zlib_checksum_ignore() { CHECK_FOCUS(__func__); - do_test_wuffs_zlib_checksum(true, 1); + return do_test_wuffs_zlib_checksum(true, 4 | 0); } -void test_wuffs_zlib_checksum_verify_bad() { +const char* test_wuffs_zlib_checksum_verify_bad0() { CHECK_FOCUS(__func__); - do_test_wuffs_zlib_checksum(false, 1); + return do_test_wuffs_zlib_checksum(false, 4 | 0); } -void test_wuffs_zlib_checksum_verify_good() { +const char* test_wuffs_zlib_checksum_verify_bad3() { CHECK_FOCUS(__func__); - do_test_wuffs_zlib_checksum(false, 0); + return do_test_wuffs_zlib_checksum(false, 4 | 3); } -void test_wuffs_zlib_decode_midsummer() { +const char* test_wuffs_zlib_checksum_verify_good() { CHECK_FOCUS(__func__); - do_test_io_buffers(wuffs_zlib_decode, &zlib_midsummer_gt, 0, 0); + return do_test_wuffs_zlib_checksum(false, 0); } -void test_wuffs_zlib_decode_pi() { +const char* test_wuffs_zlib_decode_midsummer() { CHECK_FOCUS(__func__); - do_test_io_buffers(wuffs_zlib_decode, &zlib_pi_gt, 0, 0); + return do_test_io_buffers(wuffs_zlib_decode, &zlib_midsummer_gt, 0, 0); +} + +const char* test_wuffs_zlib_decode_pi() { + CHECK_FOCUS(__func__); + return do_test_io_buffers(wuffs_zlib_decode, &zlib_pi_gt, 0, 0); } // ---------------- Mimic Tests #ifdef WUFFS_MIMIC -void test_mimic_zlib_decode_midsummer() { +const char* test_mimic_zlib_decode_midsummer() { CHECK_FOCUS(__func__); - do_test_io_buffers(mimic_zlib_decode, &zlib_midsummer_gt, 0, 0); + return do_test_io_buffers(mimic_zlib_decode, &zlib_midsummer_gt, 0, 0); } -void test_mimic_zlib_decode_pi() { +const char* test_mimic_zlib_decode_pi() { CHECK_FOCUS(__func__); - do_test_io_buffers(mimic_zlib_decode, &zlib_pi_gt, 0, 0); + return do_test_io_buffers(mimic_zlib_decode, &zlib_pi_gt, 0, 0); } #endif // WUFFS_MIMIC // ---------------- Zlib Benches -void bench_wuffs_zlib_decode_10k() { +const char* bench_wuffs_zlib_decode_10k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(wuffs_zlib_decode, tc_dst, &zlib_midsummer_gt, 0, 0, 300); + return do_bench_io_buffers(wuffs_zlib_decode, tc_dst, &zlib_midsummer_gt, 0, + 0, 300); } -void bench_wuffs_zlib_decode_100k() { +const char* bench_wuffs_zlib_decode_100k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(wuffs_zlib_decode, tc_dst, &zlib_pi_gt, 0, 0, 30); + return do_bench_io_buffers(wuffs_zlib_decode, tc_dst, &zlib_pi_gt, 0, 0, 30); } // ---------------- Mimic Benches #ifdef WUFFS_MIMIC -void bench_mimic_zlib_decode_10k() { +const char* bench_mimic_zlib_decode_10k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(mimic_zlib_decode, tc_dst, &zlib_midsummer_gt, 0, 0, 300); + return do_bench_io_buffers(mimic_zlib_decode, tc_dst, &zlib_midsummer_gt, 0, + 0, 300); } -void bench_mimic_zlib_decode_100k() { +const char* bench_mimic_zlib_decode_100k() { CHECK_FOCUS(__func__); - do_bench_io_buffers(mimic_zlib_decode, tc_dst, &zlib_pi_gt, 0, 0, 30); + return do_bench_io_buffers(mimic_zlib_decode, tc_dst, &zlib_pi_gt, 0, 0, 30); } #endif // WUFFS_MIMIC @@ -255,7 +260,8 @@ void bench_mimic_zlib_decode_100k() { proc tests[] = { test_wuffs_zlib_checksum_ignore, // - test_wuffs_zlib_checksum_verify_bad, // + test_wuffs_zlib_checksum_verify_bad0, // + test_wuffs_zlib_checksum_verify_bad3, // test_wuffs_zlib_checksum_verify_good, // test_wuffs_zlib_decode_midsummer, // test_wuffs_zlib_decode_pi, // diff --git a/test/c/testlib/testlib.c b/test/c/testlib/testlib.c index 878cc9f8..5d30c553 100644 --- a/test/c/testlib/testlib.c +++ b/test/c/testlib/testlib.c @@ -56,7 +56,9 @@ wuffs_base__slice_u8 global_pixel_slice = ((wuffs_base__slice_u8){ char fail_msg[65536] = {0}; -#define FAIL(...) snprintf(fail_msg, sizeof(fail_msg), ##__VA_ARGS__) +#define RETURN_FAIL(...) \ + snprintf(fail_msg, sizeof(fail_msg), ##__VA_ARGS__); \ + return fail_msg #define INCR_FAIL(msg, ...) \ msg += snprintf(msg, sizeof(fail_msg) - (msg - fail_msg), ##__VA_ARGS__) @@ -73,7 +75,7 @@ bool in_focus = false; proc_func_name = func_name; \ in_focus = check_focus(); \ if (!in_focus) { \ - return; \ + return NULL; \ } bool check_focus() { @@ -207,7 +209,7 @@ void bench_finish(uint64_t iters, uint64_t n_bytes) { fflush(stdout); } -typedef void (*proc)(); +typedef const char* (*proc)(); int test_main(int argc, char** argv, proc* tests, proc* benches) { bool bench = false; @@ -285,14 +287,15 @@ int test_main(int argc, char** argv, proc* tests, proc* benches) { proc* p; for (p = procs; *p; p++) { proc_func_name = "unknown_func_name"; + fail_msg[0] = 0; in_focus = false; - (*p)(); + const char* z = (*p)(); if (!in_focus) { continue; } - if (fail_msg[0]) { + if (z) { printf("%-16s%-8sFAIL %s: %s\n", proc_package_name, cc, proc_func_name, - fail_msg); + z); return 1; } if (i == 0) { @@ -380,19 +383,17 @@ const char* copy_to_io_buffer_from_pixel_buffer(wuffs_base__io_buffer* dst, return NULL; } -bool read_file(wuffs_base__io_buffer* dst, const char* path) { +const char* read_file(wuffs_base__io_buffer* dst, const char* path) { if (!dst || !path) { - FAIL("read_file: NULL argument"); - return false; + RETURN_FAIL("read_file: NULL argument"); } if (dst->meta.closed) { - FAIL("read_file: dst buffer closed for writes"); - return false; + RETURN_FAIL("read_file: dst buffer closed for writes"); } FILE* f = fopen(path, "r"); if (!f) { - FAIL("read_file(\"%s\"): %s (errno=%d)", path, strerror(errno), errno); - return false; + RETURN_FAIL("read_file(\"%s\"): %s (errno=%d)", path, strerror(errno), + errno); } uint8_t dummy[1]; @@ -411,9 +412,8 @@ bool read_file(wuffs_base__io_buffer* dst, const char* path) { len -= n; dst->meta.wi += n; } else if (n) { - FAIL("read_file(\"%s\"): EOF not reached", path); fclose(f); - return false; + RETURN_FAIL("read_file(\"%s\"): EOF not reached", path); } if (feof(f)) { break; @@ -426,20 +426,18 @@ bool read_file(wuffs_base__io_buffer* dst, const char* path) { clearerr(f); continue; } - FAIL("read_file(\"%s\"): %s (errno=%d)", path, strerror(err), err); fclose(f); - return false; + RETURN_FAIL("read_file(\"%s\"): %s (errno=%d)", path, strerror(err), err); } fclose(f); dst->meta.pos = 0; dst->meta.closed = true; - return true; + return NULL; } char* hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) { if (!msg || !buf) { - FAIL("hex_dump: NULL argument"); - return NULL; + RETURN_FAIL("hex_dump: NULL argument"); } if (buf->meta.wi == 0) { return msg; @@ -486,12 +484,11 @@ char* hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) { return msg; } -bool io_buffers_equal(const char* prefix, - wuffs_base__io_buffer* got, - wuffs_base__io_buffer* want) { +const char* check_io_buffers_equal(const char* prefix, + wuffs_base__io_buffer* got, + wuffs_base__io_buffer* want) { if (!got || !want) { - FAIL("%sio_buffers_equal: NULL argument", prefix); - return false; + RETURN_FAIL("%sio_buffers_equal: NULL argument", prefix); } char* msg = fail_msg; size_t i; @@ -507,13 +504,13 @@ bool io_buffers_equal(const char* prefix, } else if (i < got->meta.wi) { INCR_FAIL(msg, "%sio_buffers_equal: wi=%zu:\n", prefix, n); } else { - return true; + return NULL; } INCR_FAIL(msg, "contents differ at byte %zu (in hex: 0x%06zx):\n", i, i); msg = hex_dump(msg, got, i); INCR_FAIL(msg, "excerpts of got (above) versus want (below):\n"); msg = hex_dump(msg, want, i); - return false; + return fail_msg; } // throughput_counter is whether to count dst or src bytes, or neither, when @@ -526,23 +523,21 @@ typedef enum { tc_src = 2, } throughput_counter; -bool proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*, - wuffs_base__io_buffer*, - uint64_t, - uint64_t), - throughput_counter tc, - golden_test* gt, - uint64_t wlimit, - uint64_t rlimit, - uint64_t iters, - bool bench) { +const char* proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*, + wuffs_base__io_buffer*, + uint64_t, + uint64_t), + throughput_counter tc, + golden_test* gt, + uint64_t wlimit, + uint64_t rlimit, + uint64_t iters, + bool bench) { if (!codec_func) { - FAIL("NULL codec_func"); - return false; + RETURN_FAIL("NULL codec_func"); } if (!gt) { - FAIL("NULL golden_test"); - return false; + RETURN_FAIL("NULL golden_test"); } wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ @@ -557,17 +552,18 @@ bool proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*, if (!gt->src_filename) { src.meta.closed = true; - } else if (!read_file(&src, gt->src_filename)) { - return false; + } else { + const char* z = read_file(&src, gt->src_filename); + if (z) { + return z; + } } if (gt->src_offset0 || gt->src_offset1) { if (gt->src_offset0 > gt->src_offset1) { - FAIL("inconsistent src_offsets"); - return false; + RETURN_FAIL("inconsistent src_offsets"); } if (gt->src_offset1 > src.meta.wi) { - FAIL("src_offset1 too large"); - return false; + RETURN_FAIL("src_offset1 too large"); } src.meta.ri = gt->src_offset0; src.meta.wi = gt->src_offset1; @@ -581,10 +577,9 @@ bool 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* s = codec_func(&got, &src, wlimit, rlimit); - if (s) { - FAIL("%s", s); - return false; + const char* z = codec_func(&got, &src, wlimit, rlimit); + if (z) { + return z; } switch (tc) { case tc_neither: @@ -599,40 +594,41 @@ bool proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*, } if (bench) { bench_finish(iters, n_bytes); - return true; + return NULL; } if (!gt->want_filename) { want.meta.closed = true; - } else if (!read_file(&want, gt->want_filename)) { - return false; + } else { + const char* z = read_file(&want, gt->want_filename); + if (z) { + return z; + } } - if (!io_buffers_equal("", &got, &want)) { - return false; - } - return true; + return check_io_buffers_equal("", &got, &want); } -bool do_bench_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*, - wuffs_base__io_buffer*, - uint64_t, - uint64_t), - throughput_counter tc, - golden_test* gt, - uint64_t wlimit, - uint64_t rlimit, - uint64_t iters_unscaled) { +const char* do_bench_io_buffers( + const char* (*codec_func)(wuffs_base__io_buffer*, + wuffs_base__io_buffer*, + uint64_t, + uint64_t), + throughput_counter tc, + golden_test* gt, + uint64_t wlimit, + uint64_t rlimit, + uint64_t iters_unscaled) { return proc_io_buffers(codec_func, tc, gt, wlimit, rlimit, iters_unscaled * iterscale, true); } -bool do_test_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*, - wuffs_base__io_buffer*, - uint64_t, - uint64_t), - golden_test* gt, - uint64_t wlimit, - uint64_t rlimit) { +const char* do_test_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*, + wuffs_base__io_buffer*, + uint64_t, + uint64_t), + golden_test* gt, + uint64_t wlimit, + uint64_t rlimit) { return proc_io_buffers(codec_func, tc_neither, gt, wlimit, rlimit, 1, false); }