mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
Have tests return a "const char*" status
This commit is contained in:
1 parent
b6da2f4fb4
commit
6cc954d7e1
8 files changed
+771
-839
No files matched your search
+31
-31
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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);
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user