Have tests return a "const char*" status

This commit is contained in:
Nigel Tao committed 2018-09-22 08:43:56 +10:00
1 parent b6da2f4fb4
commit 6cc954d7e1
8 files changed
+771 -839

No files matched your search

+31 -31
View File
@@ -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
+30 -30
View File
@@ -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
+156 -152
View File
@@ -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
+328 -398
View File
@@ -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
+43 -43
View File
@@ -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, //
+66 -70
View File
@@ -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
+47 -41
View File
@@ -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, //
+70 -74
View File
@@ -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);
}