mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
Have test/* global variable names start with g_
This commit is contained in:
1 parent
c0bd9df978
commit
b72dd16f9b
11 files changed
+458
-453
No files matched your search
+13
-13
@@ -69,11 +69,11 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
|
||||
|
||||
// ---------------- Golden Tests
|
||||
|
||||
golden_test adler32_midsummer_gt = {
|
||||
golden_test g_adler32_midsummer_gt = {
|
||||
.src_filename = "test/data/midsummer.txt",
|
||||
};
|
||||
|
||||
golden_test adler32_pi_gt = {
|
||||
golden_test g_adler32_pi_gt = {
|
||||
.src_filename = "test/data/pi.txt",
|
||||
};
|
||||
|
||||
@@ -134,7 +134,7 @@ test_wuffs_adler32_golden() {
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, test_cases[tc].filename));
|
||||
|
||||
@@ -230,7 +230,7 @@ test_wuffs_adler32_pi() {
|
||||
|
||||
// ---------------- Adler32 Benches
|
||||
|
||||
uint32_t global_wuffs_adler32_unused_u32;
|
||||
uint32_t g_wuffs_adler32_unused_u32;
|
||||
|
||||
const char* //
|
||||
wuffs_bench_adler32(wuffs_base__io_buffer* dst,
|
||||
@@ -246,7 +246,7 @@ wuffs_bench_adler32(wuffs_base__io_buffer* dst,
|
||||
CHECK_STATUS("initialize", wuffs_adler32__hasher__initialize(
|
||||
&checksum, sizeof checksum, WUFFS_VERSION,
|
||||
wuffs_initialize_flags));
|
||||
global_wuffs_adler32_unused_u32 = wuffs_adler32__hasher__update_u32(
|
||||
g_wuffs_adler32_unused_u32 = wuffs_adler32__hasher__update_u32(
|
||||
&checksum, ((wuffs_base__slice_u8){
|
||||
.ptr = src->data.ptr + src->meta.ri,
|
||||
.len = len,
|
||||
@@ -261,7 +261,7 @@ bench_wuffs_adler32_10k() {
|
||||
return do_bench_io_buffers(
|
||||
wuffs_bench_adler32,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tcounter_src,
|
||||
&adler32_midsummer_gt, UINT64_MAX, UINT64_MAX, 1500);
|
||||
&g_adler32_midsummer_gt, UINT64_MAX, UINT64_MAX, 1500);
|
||||
}
|
||||
|
||||
const char* //
|
||||
@@ -270,7 +270,7 @@ bench_wuffs_adler32_100k() {
|
||||
return do_bench_io_buffers(
|
||||
wuffs_bench_adler32,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tcounter_src,
|
||||
&adler32_pi_gt, UINT64_MAX, UINT64_MAX, 150);
|
||||
&g_adler32_pi_gt, UINT64_MAX, UINT64_MAX, 150);
|
||||
}
|
||||
|
||||
// ---------------- Mimic Benches
|
||||
@@ -281,7 +281,7 @@ const char* //
|
||||
bench_mimic_adler32_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_bench_adler32, 0, tcounter_src,
|
||||
&adler32_midsummer_gt, UINT64_MAX, UINT64_MAX,
|
||||
&g_adler32_midsummer_gt, UINT64_MAX, UINT64_MAX,
|
||||
1500);
|
||||
}
|
||||
|
||||
@@ -289,7 +289,7 @@ const char* //
|
||||
bench_mimic_adler32_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_bench_adler32, 0, tcounter_src,
|
||||
&adler32_pi_gt, UINT64_MAX, UINT64_MAX, 150);
|
||||
&g_adler32_pi_gt, UINT64_MAX, UINT64_MAX, 150);
|
||||
}
|
||||
|
||||
#endif // WUFFS_MIMIC
|
||||
@@ -299,7 +299,7 @@ bench_mimic_adler32_100k() {
|
||||
// Note that the adler32 mimic tests and benches don't work with
|
||||
// WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB.
|
||||
|
||||
proc tests[] = {
|
||||
proc g_tests[] = {
|
||||
|
||||
test_wuffs_adler32_golden,
|
||||
test_wuffs_adler32_interface,
|
||||
@@ -308,7 +308,7 @@ proc tests[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
proc benches[] = {
|
||||
proc g_benches[] = {
|
||||
|
||||
bench_wuffs_adler32_10k,
|
||||
bench_wuffs_adler32_100k,
|
||||
@@ -325,6 +325,6 @@ proc benches[] = {
|
||||
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/adler32";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
g_proc_package_name = "std/adler32";
|
||||
return test_main(argc, argv, g_tests, g_benches);
|
||||
}
|
||||
+5
-5
@@ -93,7 +93,7 @@ test_wuffs_bmp_decode_frame_config() {
|
||||
|
||||
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/hat.bmp"));
|
||||
CHECK_STATUS("decode_frame_config #0",
|
||||
@@ -134,7 +134,7 @@ test_wuffs_bmp_decode_frame_config() {
|
||||
|
||||
// ---------------- Manifest
|
||||
|
||||
proc tests[] = {
|
||||
proc g_tests[] = {
|
||||
|
||||
test_wuffs_bmp_decode_frame_config,
|
||||
test_wuffs_bmp_decode_interface,
|
||||
@@ -148,7 +148,7 @@ proc tests[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
proc benches[] = {
|
||||
proc g_benches[] = {
|
||||
|
||||
// No BMP benches.
|
||||
|
||||
@@ -163,6 +163,6 @@ proc benches[] = {
|
||||
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/bmp";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
g_proc_package_name = "std/bmp";
|
||||
return test_main(argc, argv, g_tests, g_benches);
|
||||
}
|
||||
+14
-13
@@ -69,11 +69,11 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
|
||||
|
||||
// ---------------- Golden Tests
|
||||
|
||||
golden_test crc32_midsummer_gt = {
|
||||
golden_test g_crc32_midsummer_gt = {
|
||||
.src_filename = "test/data/midsummer.txt",
|
||||
};
|
||||
|
||||
golden_test crc32_pi_gt = {
|
||||
golden_test g_crc32_pi_gt = {
|
||||
.src_filename = "test/data/pi.txt",
|
||||
};
|
||||
|
||||
@@ -134,7 +134,7 @@ test_wuffs_crc32_ieee_golden() {
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, test_cases[tc].filename));
|
||||
|
||||
@@ -267,7 +267,7 @@ test_mimic_crc32_ieee_pi() {
|
||||
|
||||
// ---------------- CRC32 Benches
|
||||
|
||||
uint32_t global_wuffs_crc32_unused_u32;
|
||||
uint32_t g_wuffs_crc32_unused_u32;
|
||||
|
||||
const char* //
|
||||
wuffs_bench_crc32_ieee(wuffs_base__io_buffer* dst,
|
||||
@@ -283,7 +283,7 @@ wuffs_bench_crc32_ieee(wuffs_base__io_buffer* dst,
|
||||
CHECK_STATUS("initialize", wuffs_crc32__ieee_hasher__initialize(
|
||||
&checksum, sizeof checksum, WUFFS_VERSION,
|
||||
wuffs_initialize_flags));
|
||||
global_wuffs_crc32_unused_u32 = wuffs_crc32__ieee_hasher__update_u32(
|
||||
g_wuffs_crc32_unused_u32 = wuffs_crc32__ieee_hasher__update_u32(
|
||||
&checksum, ((wuffs_base__slice_u8){
|
||||
.ptr = src->data.ptr + src->meta.ri,
|
||||
.len = len,
|
||||
@@ -298,7 +298,7 @@ bench_wuffs_crc32_ieee_10k() {
|
||||
return do_bench_io_buffers(
|
||||
wuffs_bench_crc32_ieee,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tcounter_src,
|
||||
&crc32_midsummer_gt, UINT64_MAX, UINT64_MAX, 1500);
|
||||
&g_crc32_midsummer_gt, UINT64_MAX, UINT64_MAX, 1500);
|
||||
}
|
||||
|
||||
const char* //
|
||||
@@ -307,7 +307,7 @@ bench_wuffs_crc32_ieee_100k() {
|
||||
return do_bench_io_buffers(
|
||||
wuffs_bench_crc32_ieee,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tcounter_src,
|
||||
&crc32_pi_gt, UINT64_MAX, UINT64_MAX, 150);
|
||||
&g_crc32_pi_gt, UINT64_MAX, UINT64_MAX, 150);
|
||||
}
|
||||
|
||||
// ---------------- Mimic Benches
|
||||
@@ -318,14 +318,15 @@ const char* //
|
||||
bench_mimic_crc32_ieee_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_bench_crc32_ieee, 0, tcounter_src,
|
||||
&crc32_midsummer_gt, UINT64_MAX, UINT64_MAX, 1500);
|
||||
&g_crc32_midsummer_gt, UINT64_MAX, UINT64_MAX,
|
||||
1500);
|
||||
}
|
||||
|
||||
const char* //
|
||||
bench_mimic_crc32_ieee_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_bench_crc32_ieee, 0, tcounter_src,
|
||||
&crc32_pi_gt, UINT64_MAX, UINT64_MAX, 150);
|
||||
&g_crc32_pi_gt, UINT64_MAX, UINT64_MAX, 150);
|
||||
}
|
||||
|
||||
#endif // WUFFS_MIMIC
|
||||
@@ -335,7 +336,7 @@ bench_mimic_crc32_ieee_100k() {
|
||||
// Note that the crc32 mimic tests and benches don't work with
|
||||
// WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB.
|
||||
|
||||
proc tests[] = {
|
||||
proc g_tests[] = {
|
||||
|
||||
test_wuffs_crc32_ieee_golden,
|
||||
test_wuffs_crc32_ieee_interface,
|
||||
@@ -350,7 +351,7 @@ proc tests[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
proc benches[] = {
|
||||
proc g_benches[] = {
|
||||
|
||||
bench_wuffs_crc32_ieee_10k,
|
||||
bench_wuffs_crc32_ieee_100k,
|
||||
@@ -367,6 +368,6 @@ proc benches[] = {
|
||||
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/crc32";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
g_proc_package_name = "std/crc32";
|
||||
return test_main(argc, argv, g_tests, g_benches);
|
||||
}
|
||||
+70
-70
@@ -73,14 +73,14 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
|
||||
//
|
||||
// go run script/extract-flate-offsets.go test/data/*.gz
|
||||
|
||||
golden_test deflate_256_bytes_gt = {
|
||||
golden_test g_deflate_256_bytes_gt = {
|
||||
.want_filename = "test/data/artificial/256.bytes",
|
||||
.src_filename = "test/data/artificial/256.bytes.gz",
|
||||
.src_offset0 = 20,
|
||||
.src_offset1 = 281,
|
||||
};
|
||||
|
||||
golden_test deflate_deflate_backref_crosses_blocks_gt = {
|
||||
golden_test g_deflate_deflate_backref_crosses_blocks_gt = {
|
||||
.want_filename =
|
||||
"test/data/artificial/"
|
||||
"deflate-backref-crosses-blocks.deflate.decompressed",
|
||||
@@ -89,7 +89,7 @@ golden_test deflate_deflate_backref_crosses_blocks_gt = {
|
||||
"deflate-backref-crosses-blocks.deflate",
|
||||
};
|
||||
|
||||
golden_test deflate_deflate_degenerate_huffman_unused_gt = {
|
||||
golden_test g_deflate_deflate_degenerate_huffman_unused_gt = {
|
||||
.want_filename =
|
||||
"test/data/artificial/"
|
||||
"deflate-degenerate-huffman-unused.deflate.decompressed",
|
||||
@@ -98,7 +98,7 @@ golden_test deflate_deflate_degenerate_huffman_unused_gt = {
|
||||
"deflate-degenerate-huffman-unused.deflate",
|
||||
};
|
||||
|
||||
golden_test deflate_deflate_distance_32768_gt = {
|
||||
golden_test g_deflate_deflate_distance_32768_gt = {
|
||||
.want_filename =
|
||||
"test/data/artificial/"
|
||||
"deflate-distance-32768.deflate.decompressed",
|
||||
@@ -107,7 +107,7 @@ golden_test deflate_deflate_distance_32768_gt = {
|
||||
"deflate-distance-32768.deflate",
|
||||
};
|
||||
|
||||
golden_test deflate_deflate_distance_code_31_gt = {
|
||||
golden_test g_deflate_deflate_distance_code_31_gt = {
|
||||
.want_filename =
|
||||
"test/data/artificial/"
|
||||
"qdeflate-distance-code-31.deflate.decompressed",
|
||||
@@ -116,7 +116,7 @@ golden_test deflate_deflate_distance_code_31_gt = {
|
||||
"deflate-distance-code-31.deflate",
|
||||
};
|
||||
|
||||
golden_test deflate_deflate_huffman_primlen_9_gt = {
|
||||
golden_test g_deflate_deflate_huffman_primlen_9_gt = {
|
||||
.want_filename =
|
||||
"test/data/artificial/"
|
||||
"deflate-huffman-primlen-9.deflate.decompressed",
|
||||
@@ -125,28 +125,28 @@ golden_test deflate_deflate_huffman_primlen_9_gt = {
|
||||
"deflate-huffman-primlen-9.deflate",
|
||||
};
|
||||
|
||||
golden_test deflate_midsummer_gt = {
|
||||
golden_test g_deflate_midsummer_gt = {
|
||||
.want_filename = "test/data/midsummer.txt",
|
||||
.src_filename = "test/data/midsummer.txt.gz",
|
||||
.src_offset0 = 24,
|
||||
.src_offset1 = 5166,
|
||||
};
|
||||
|
||||
golden_test deflate_pi_gt = {
|
||||
golden_test g_deflate_pi_gt = {
|
||||
.want_filename = "test/data/pi.txt",
|
||||
.src_filename = "test/data/pi.txt.gz",
|
||||
.src_offset0 = 17,
|
||||
.src_offset1 = 48335,
|
||||
};
|
||||
|
||||
golden_test deflate_romeo_gt = {
|
||||
golden_test g_deflate_romeo_gt = {
|
||||
.want_filename = "test/data/romeo.txt",
|
||||
.src_filename = "test/data/romeo.txt.gz",
|
||||
.src_offset0 = 20,
|
||||
.src_offset1 = 550,
|
||||
};
|
||||
|
||||
golden_test deflate_romeo_fixed_gt = {
|
||||
golden_test g_deflate_romeo_fixed_gt = {
|
||||
.want_filename = "test/data/romeo.txt",
|
||||
.src_filename = "test/data/romeo.txt.fixed-huff.deflate",
|
||||
};
|
||||
@@ -182,7 +182,7 @@ wuffs_deflate_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer limited_src = make_limited_reader(*src, rlimit);
|
||||
|
||||
wuffs_base__status status = wuffs_deflate__decoder__transform_io(
|
||||
&dec, &limited_dst, &limited_src, global_work_slice);
|
||||
&dec, &limited_dst, &limited_src, g_work_slice_u8);
|
||||
|
||||
dst->meta.wi += limited_dst.meta.wi;
|
||||
src->meta.ri += limited_src.meta.ri;
|
||||
@@ -200,7 +200,7 @@ wuffs_deflate_decode(wuffs_base__io_buffer* dst,
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_256_bytes() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &deflate_256_bytes_gt,
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &g_deflate_256_bytes_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
@@ -208,7 +208,7 @@ const char* //
|
||||
test_wuffs_deflate_decode_deflate_backref_crosses_blocks() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode,
|
||||
&deflate_deflate_backref_crosses_blocks_gt,
|
||||
&g_deflate_deflate_backref_crosses_blocks_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
@@ -216,7 +216,7 @@ const char* //
|
||||
test_wuffs_deflate_decode_deflate_degenerate_huffman_unused() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode,
|
||||
&deflate_deflate_degenerate_huffman_unused_gt,
|
||||
&g_deflate_deflate_degenerate_huffman_unused_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
@@ -224,7 +224,7 @@ const char* //
|
||||
test_wuffs_deflate_decode_deflate_distance_32768() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode,
|
||||
&deflate_deflate_distance_32768_gt, UINT64_MAX,
|
||||
&g_deflate_deflate_distance_32768_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
@@ -232,7 +232,7 @@ const char* //
|
||||
test_wuffs_deflate_decode_deflate_distance_code_31() {
|
||||
CHECK_FOCUS(__func__);
|
||||
const char* have = do_test_io_buffers(wuffs_deflate_decode,
|
||||
&deflate_deflate_distance_code_31_gt,
|
||||
&g_deflate_deflate_distance_code_31_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
if (have != wuffs_deflate__error__bad_huffman_code) {
|
||||
RETURN_FAIL("have \"%s\", want \"%s\"", have,
|
||||
@@ -247,19 +247,19 @@ test_wuffs_deflate_decode_deflate_huffman_primlen_9() {
|
||||
|
||||
// First, treat this like any other compare-to-golden test.
|
||||
CHECK_STRING(do_test_io_buffers(wuffs_deflate_decode,
|
||||
&deflate_deflate_huffman_primlen_9_gt,
|
||||
&g_deflate_deflate_huffman_primlen_9_gt,
|
||||
UINT64_MAX, UINT64_MAX));
|
||||
|
||||
// Second, check that the decoder's huffman table sizes match those predicted
|
||||
// by the script/print-deflate-huff-table-size.go program.
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
|
||||
golden_test* gt = &deflate_deflate_huffman_primlen_9_gt;
|
||||
golden_test* gt = &g_deflate_deflate_huffman_primlen_9_gt;
|
||||
CHECK_STRING(read_file(&src, gt->src_filename));
|
||||
|
||||
wuffs_deflate__decoder dec;
|
||||
@@ -267,7 +267,7 @@ test_wuffs_deflate_decode_deflate_huffman_primlen_9() {
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__DEFAULT_OPTIONS));
|
||||
CHECK_STATUS("transform_io", wuffs_deflate__decoder__transform_io(
|
||||
&dec, &have, &src, global_work_slice));
|
||||
&dec, &have, &src, g_work_slice_u8));
|
||||
|
||||
int i;
|
||||
for (i = 0; i < 2; i++) {
|
||||
@@ -291,48 +291,48 @@ test_wuffs_deflate_decode_deflate_huffman_primlen_9() {
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_midsummer() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &deflate_midsummer_gt,
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &g_deflate_midsummer_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_pi_just_one_read() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, UINT64_MAX,
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &g_deflate_pi_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_pi_many_big_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, UINT64_MAX,
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &g_deflate_pi_gt, UINT64_MAX,
|
||||
4096);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_pi_many_medium_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, UINT64_MAX,
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &g_deflate_pi_gt, UINT64_MAX,
|
||||
599);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_pi_many_small_writes_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 59, 61);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &g_deflate_pi_gt, 59, 61);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_romeo() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &deflate_romeo_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &g_deflate_romeo_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_romeo_fixed() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &deflate_romeo_fixed_gt,
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &g_deflate_romeo_fixed_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
@@ -341,16 +341,16 @@ test_wuffs_deflate_decode_split_src() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
|
||||
.data = global_want_slice,
|
||||
.data = g_want_slice_u8,
|
||||
});
|
||||
|
||||
golden_test* gt = &deflate_256_bytes_gt;
|
||||
golden_test* gt = &g_deflate_256_bytes_gt;
|
||||
CHECK_STRING(read_file(&src, gt->src_filename));
|
||||
CHECK_STRING(read_file(&want, gt->want_filename));
|
||||
|
||||
@@ -372,13 +372,13 @@ test_wuffs_deflate_decode_split_src() {
|
||||
src.meta.ri = gt->src_offset0;
|
||||
src.meta.wi = split;
|
||||
wuffs_base__status z0 = wuffs_deflate__decoder__transform_io(
|
||||
&dec, &have, &src, global_work_slice);
|
||||
&dec, &have, &src, g_work_slice_u8);
|
||||
|
||||
src.meta.closed = true;
|
||||
src.meta.ri = split;
|
||||
src.meta.wi = gt->src_offset1;
|
||||
wuffs_base__status z1 = wuffs_deflate__decoder__transform_io(
|
||||
&dec, &have, &src, global_work_slice);
|
||||
&dec, &have, &src, g_work_slice_u8);
|
||||
|
||||
if (z0.repr != wuffs_base__suspension__short_read) {
|
||||
RETURN_FAIL("i=%d: z0: have \"%s\", want \"%s\"", i, z0.repr,
|
||||
@@ -415,7 +415,7 @@ do_test_wuffs_deflate_history(int i,
|
||||
dec->private_impl.f_history_index = starting_history_index;
|
||||
|
||||
wuffs_base__status have_z = wuffs_deflate__decoder__transform_io(
|
||||
dec, &limited_have, src, global_work_slice);
|
||||
dec, &limited_have, src, g_work_slice_u8);
|
||||
have->meta.wi += limited_have.meta.wi;
|
||||
if (have_z.repr != want_z) {
|
||||
RETURN_FAIL("i=%d: starting_history_index=0x%04" PRIX32
|
||||
@@ -454,16 +454,16 @@ test_wuffs_deflate_history_full() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
|
||||
.data = global_want_slice,
|
||||
.data = g_want_slice_u8,
|
||||
});
|
||||
|
||||
golden_test* gt = &deflate_pi_gt;
|
||||
golden_test* gt = &g_deflate_pi_gt;
|
||||
CHECK_STRING(read_file(&src, gt->src_filename));
|
||||
CHECK_STRING(read_file(&want, gt->want_filename));
|
||||
|
||||
@@ -501,7 +501,7 @@ test_wuffs_deflate_history_full() {
|
||||
}
|
||||
wuffs_base__io_buffer history_want = ((wuffs_base__io_buffer){
|
||||
.data = ((wuffs_base__slice_u8){
|
||||
.ptr = global_want_array + want.meta.wi - (full_history_size - i),
|
||||
.ptr = g_want_array_u8 + want.meta.wi - (full_history_size - i),
|
||||
.len = full_history_size,
|
||||
}),
|
||||
});
|
||||
@@ -517,13 +517,13 @@ test_wuffs_deflate_history_partial() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
|
||||
golden_test* gt = &deflate_pi_gt;
|
||||
golden_test* gt = &g_deflate_pi_gt;
|
||||
CHECK_STRING(read_file(&src, gt->src_filename));
|
||||
|
||||
uint32_t starting_history_indexes[] = {
|
||||
@@ -715,7 +715,7 @@ test_wuffs_deflate_table_redirect() {
|
||||
const char* //
|
||||
test_mimic_deflate_decode_256_bytes() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode, &deflate_256_bytes_gt,
|
||||
return do_test_io_buffers(mimic_deflate_decode, &g_deflate_256_bytes_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
@@ -723,7 +723,7 @@ const char* //
|
||||
test_mimic_deflate_decode_deflate_backref_crosses_blocks() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode,
|
||||
&deflate_deflate_backref_crosses_blocks_gt,
|
||||
&g_deflate_deflate_backref_crosses_blocks_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
@@ -731,7 +731,7 @@ const char* //
|
||||
test_mimic_deflate_decode_deflate_degenerate_huffman_unused() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode,
|
||||
&deflate_deflate_degenerate_huffman_unused_gt,
|
||||
&g_deflate_deflate_degenerate_huffman_unused_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
@@ -739,7 +739,7 @@ const char* //
|
||||
test_mimic_deflate_decode_deflate_distance_32768() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode,
|
||||
&deflate_deflate_distance_32768_gt, UINT64_MAX,
|
||||
&g_deflate_deflate_distance_32768_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
@@ -747,7 +747,7 @@ const char* //
|
||||
test_mimic_deflate_decode_deflate_distance_code_31() {
|
||||
CHECK_FOCUS(__func__);
|
||||
const char* have = do_test_io_buffers(mimic_deflate_decode,
|
||||
&deflate_deflate_distance_code_31_gt,
|
||||
&g_deflate_deflate_distance_code_31_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
const char* want = "inflate failed (data error)";
|
||||
if ((have != want) &&
|
||||
@@ -761,42 +761,42 @@ const char* //
|
||||
test_mimic_deflate_decode_deflate_huffman_primlen_9() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode,
|
||||
&deflate_deflate_huffman_primlen_9_gt, UINT64_MAX,
|
||||
&g_deflate_deflate_huffman_primlen_9_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_mimic_deflate_decode_midsummer() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode, &deflate_midsummer_gt,
|
||||
return do_test_io_buffers(mimic_deflate_decode, &g_deflate_midsummer_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_mimic_deflate_decode_pi_just_one_read() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode, &deflate_pi_gt, UINT64_MAX,
|
||||
return do_test_io_buffers(mimic_deflate_decode, &g_deflate_pi_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_mimic_deflate_decode_pi_many_big_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode, &deflate_pi_gt, UINT64_MAX,
|
||||
return do_test_io_buffers(mimic_deflate_decode, &g_deflate_pi_gt, UINT64_MAX,
|
||||
4096);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_mimic_deflate_decode_romeo() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode, &deflate_romeo_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
return do_test_io_buffers(mimic_deflate_decode, &g_deflate_romeo_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_mimic_deflate_decode_romeo_fixed() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode, &deflate_romeo_fixed_gt,
|
||||
return do_test_io_buffers(mimic_deflate_decode, &g_deflate_romeo_fixed_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
@@ -809,7 +809,7 @@ bench_wuffs_deflate_decode_1k_full_init() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(wuffs_deflate_decode,
|
||||
WUFFS_INITIALIZE__DEFAULT_OPTIONS, tcounter_dst,
|
||||
&deflate_romeo_gt, UINT64_MAX, UINT64_MAX, 2000);
|
||||
&g_deflate_romeo_gt, UINT64_MAX, UINT64_MAX, 2000);
|
||||
}
|
||||
|
||||
const char* //
|
||||
@@ -818,7 +818,7 @@ bench_wuffs_deflate_decode_1k_part_init() {
|
||||
return do_bench_io_buffers(
|
||||
wuffs_deflate_decode,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tcounter_dst,
|
||||
&deflate_romeo_gt, UINT64_MAX, UINT64_MAX, 2000);
|
||||
&g_deflate_romeo_gt, UINT64_MAX, UINT64_MAX, 2000);
|
||||
}
|
||||
|
||||
const char* //
|
||||
@@ -826,7 +826,7 @@ bench_wuffs_deflate_decode_10k_full_init() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_deflate_decode, WUFFS_INITIALIZE__DEFAULT_OPTIONS, tcounter_dst,
|
||||
&deflate_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
&g_deflate_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
}
|
||||
|
||||
const char* //
|
||||
@@ -835,7 +835,7 @@ bench_wuffs_deflate_decode_10k_part_init() {
|
||||
return do_bench_io_buffers(
|
||||
wuffs_deflate_decode,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tcounter_dst,
|
||||
&deflate_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
&g_deflate_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
}
|
||||
|
||||
const char* //
|
||||
@@ -844,7 +844,7 @@ bench_wuffs_deflate_decode_100k_just_one_read() {
|
||||
return do_bench_io_buffers(
|
||||
wuffs_deflate_decode,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tcounter_dst,
|
||||
&deflate_pi_gt, UINT64_MAX, UINT64_MAX, 30);
|
||||
&g_deflate_pi_gt, UINT64_MAX, UINT64_MAX, 30);
|
||||
}
|
||||
|
||||
const char* //
|
||||
@@ -853,7 +853,7 @@ bench_wuffs_deflate_decode_100k_many_big_reads() {
|
||||
return do_bench_io_buffers(
|
||||
wuffs_deflate_decode,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tcounter_dst,
|
||||
&deflate_pi_gt, UINT64_MAX, 4096, 30);
|
||||
&g_deflate_pi_gt, UINT64_MAX, 4096, 30);
|
||||
}
|
||||
|
||||
// ---------------- Mimic Benches
|
||||
@@ -864,14 +864,14 @@ const char* //
|
||||
bench_mimic_deflate_decode_1k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_deflate_decode, 0, tcounter_dst,
|
||||
&deflate_romeo_gt, UINT64_MAX, UINT64_MAX, 2000);
|
||||
&g_deflate_romeo_gt, UINT64_MAX, UINT64_MAX, 2000);
|
||||
}
|
||||
|
||||
const char* //
|
||||
bench_mimic_deflate_decode_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_deflate_decode, 0, tcounter_dst,
|
||||
&deflate_midsummer_gt, UINT64_MAX, UINT64_MAX,
|
||||
&g_deflate_midsummer_gt, UINT64_MAX, UINT64_MAX,
|
||||
300);
|
||||
}
|
||||
|
||||
@@ -879,21 +879,21 @@ const char* //
|
||||
bench_mimic_deflate_decode_100k_just_one_read() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_deflate_decode, 0, tcounter_dst,
|
||||
&deflate_pi_gt, UINT64_MAX, UINT64_MAX, 30);
|
||||
&g_deflate_pi_gt, UINT64_MAX, UINT64_MAX, 30);
|
||||
}
|
||||
|
||||
const char* //
|
||||
bench_mimic_deflate_decode_100k_many_big_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_deflate_decode, 0, tcounter_dst,
|
||||
&deflate_pi_gt, UINT64_MAX, 4096, 30);
|
||||
&g_deflate_pi_gt, UINT64_MAX, 4096, 30);
|
||||
}
|
||||
|
||||
#endif // WUFFS_MIMIC
|
||||
|
||||
// ---------------- Manifest
|
||||
|
||||
proc tests[] = {
|
||||
proc g_tests[] = {
|
||||
|
||||
test_wuffs_deflate_decode_256_bytes,
|
||||
test_wuffs_deflate_decode_deflate_backref_crosses_blocks,
|
||||
@@ -933,7 +933,7 @@ proc tests[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
proc benches[] = {
|
||||
proc g_benches[] = {
|
||||
|
||||
bench_wuffs_deflate_decode_1k_full_init,
|
||||
bench_wuffs_deflate_decode_1k_part_init,
|
||||
@@ -956,6 +956,6 @@ proc benches[] = {
|
||||
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/deflate";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
g_proc_package_name = "std/deflate";
|
||||
return test_main(argc, argv, g_tests, g_benches);
|
||||
}
|
||||
+73
-71
@@ -217,7 +217,7 @@ wuffs_gif_decode(wuffs_base__io_buffer* dst,
|
||||
|
||||
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
|
||||
CHECK_STATUS("set_from_slice", wuffs_base__pixel_buffer__set_from_slice(
|
||||
&pb, &ic.pixcfg, global_pixel_slice));
|
||||
&pb, &ic.pixcfg, g_pixel_slice_u8));
|
||||
|
||||
while (true) {
|
||||
wuffs_base__status status =
|
||||
@@ -230,7 +230,7 @@ wuffs_gif_decode(wuffs_base__io_buffer* dst,
|
||||
CHECK_STATUS("decode_frame",
|
||||
wuffs_gif__decoder__decode_frame(&dec, &pb, src,
|
||||
WUFFS_BASE__PIXEL_BLEND__SRC,
|
||||
global_work_slice, NULL));
|
||||
g_work_slice_u8, NULL));
|
||||
|
||||
CHECK_STRING(copy_to_io_buffer_from_pixel_buffer(
|
||||
dst, &pb, wuffs_base__frame_config__bounds(&fc)));
|
||||
@@ -245,10 +245,10 @@ do_test_wuffs_gif_decode(const char* filename,
|
||||
uint64_t rlimit,
|
||||
wuffs_base__pixel_format dst_pixfmt) {
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, filename));
|
||||
|
||||
@@ -290,7 +290,7 @@ do_test_wuffs_gif_decode(const char* filename,
|
||||
120);
|
||||
|
||||
CHECK_STATUS("set_from_slice", wuffs_base__pixel_buffer__set_from_slice(
|
||||
&pb, &ic.pixcfg, global_pixel_slice));
|
||||
&pb, &ic.pixcfg, g_pixel_slice_u8));
|
||||
|
||||
uint32_t have = wuffs_gif__decoder__num_animation_loops(&dec);
|
||||
if (have != 1) {
|
||||
@@ -330,8 +330,8 @@ do_test_wuffs_gif_decode(const char* filename,
|
||||
size_t old_ri = src.meta.ri;
|
||||
|
||||
wuffs_base__status status = wuffs_gif__decoder__decode_frame(
|
||||
&dec, &pb, &limited_src, WUFFS_BASE__PIXEL_BLEND__SRC,
|
||||
global_work_slice, NULL);
|
||||
&dec, &pb, &limited_src, WUFFS_BASE__PIXEL_BLEND__SRC, g_work_slice_u8,
|
||||
NULL);
|
||||
src.meta.ri += limited_src.meta.ri;
|
||||
|
||||
if (wuffs_base__status__is_ok(&status)) {
|
||||
@@ -380,14 +380,14 @@ do_test_wuffs_gif_decode(const char* filename,
|
||||
}
|
||||
|
||||
wuffs_base__io_buffer ind_want = ((wuffs_base__io_buffer){
|
||||
.data = global_want_slice,
|
||||
.data = g_want_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&ind_want, indexes_filename));
|
||||
if (dst_pixfmt.repr == WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY) {
|
||||
CHECK_STRING(check_io_buffers_equal("indexes ", &have, &ind_want));
|
||||
} else {
|
||||
wuffs_base__io_buffer expanded_want = ((wuffs_base__io_buffer){
|
||||
.data = global_work_slice,
|
||||
.data = g_work_slice_u8,
|
||||
});
|
||||
if (ind_want.meta.wi > (expanded_want.data.len / 4)) {
|
||||
RETURN_FAIL("indexes are too long to expand into the work buffer");
|
||||
@@ -455,7 +455,7 @@ do_test_wuffs_gif_decode(const char* filename,
|
||||
RETURN_FAIL("decode_frame returned \"ok\" but src was exhausted");
|
||||
}
|
||||
wuffs_base__status status = wuffs_gif__decoder__decode_frame(
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, global_work_slice, NULL);
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, g_work_slice_u8, NULL);
|
||||
if (status.repr != wuffs_base__note__end_of_data) {
|
||||
RETURN_FAIL("decode_frame: have \"%s\", want \"%s\"", status.repr,
|
||||
wuffs_base__note__end_of_data);
|
||||
@@ -489,10 +489,10 @@ do_test_wuffs_gif_decode_expecting(wuffs_base__io_buffer src,
|
||||
|
||||
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
|
||||
CHECK_STATUS("set_from_slice", wuffs_base__pixel_buffer__set_from_slice(
|
||||
&pb, &ic.pixcfg, global_pixel_slice));
|
||||
&pb, &ic.pixcfg, g_pixel_slice_u8));
|
||||
|
||||
wuffs_base__status status = wuffs_gif__decoder__decode_frame(
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, global_work_slice, NULL);
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, g_work_slice_u8, NULL);
|
||||
if (status.repr != want_status) {
|
||||
RETURN_FAIL("decode_frame: have \"%s\", want \"%s\"", status.repr,
|
||||
want_status);
|
||||
@@ -512,7 +512,7 @@ const char* //
|
||||
test_wuffs_gif_call_interleaved() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/bricks-dither.gif"));
|
||||
|
||||
@@ -553,7 +553,7 @@ const char* //
|
||||
test_wuffs_gif_call_sequence() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/bricks-dither.gif"));
|
||||
|
||||
@@ -582,7 +582,7 @@ do_test_wuffs_gif_decode_animated(
|
||||
uint32_t want_num_frames,
|
||||
wuffs_base__rect_ie_u32* want_frame_config_bounds) {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, filename));
|
||||
|
||||
@@ -605,7 +605,7 @@ do_test_wuffs_gif_decode_animated(
|
||||
|
||||
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
|
||||
CHECK_STATUS("set_from_slice", wuffs_base__pixel_buffer__set_from_slice(
|
||||
&pb, &ic.pixcfg, global_pixel_slice));
|
||||
&pb, &ic.pixcfg, g_pixel_slice_u8));
|
||||
|
||||
uint32_t i;
|
||||
for (i = 0; i < want_num_frames; i++) {
|
||||
@@ -630,7 +630,7 @@ do_test_wuffs_gif_decode_animated(
|
||||
}
|
||||
|
||||
status = wuffs_gif__decoder__decode_frame(
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, global_work_slice, NULL);
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, g_work_slice_u8, NULL);
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
RETURN_FAIL("decode_frame #%" PRIu32 ": \"%s\"", i, status.repr);
|
||||
}
|
||||
@@ -647,7 +647,7 @@ do_test_wuffs_gif_decode_animated(
|
||||
// decode_frame.
|
||||
for (i = 0; i < 3; i++) {
|
||||
wuffs_base__status status = wuffs_gif__decoder__decode_frame(
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, global_work_slice, NULL);
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, g_work_slice_u8, NULL);
|
||||
if (status.repr != wuffs_base__note__end_of_data) {
|
||||
RETURN_FAIL("decode_frame: have \"%s\", want \"%s\"", status.repr,
|
||||
wuffs_base__note__end_of_data);
|
||||
@@ -700,7 +700,7 @@ const char* //
|
||||
test_wuffs_gif_decode_delay_num_frames_decoded() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/animated-red-blue.gif"));
|
||||
if (src.meta.wi < 1) {
|
||||
@@ -750,7 +750,7 @@ const char* //
|
||||
test_wuffs_gif_decode_empty_palette() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/artificial/gif-empty-palette.gif"));
|
||||
int q;
|
||||
@@ -774,16 +774,15 @@ test_wuffs_gif_decode_empty_palette() {
|
||||
|
||||
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
|
||||
status = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
|
||||
global_pixel_slice);
|
||||
g_pixel_slice_u8);
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
RETURN_FAIL("q=%d: set_from_slice: \"%s\"", q, status.repr);
|
||||
}
|
||||
|
||||
int i;
|
||||
for (i = 0; i < 2; i++) {
|
||||
status = wuffs_gif__decoder__decode_frame(&dec, &pb, &src,
|
||||
WUFFS_BASE__PIXEL_BLEND__SRC,
|
||||
global_work_slice, NULL);
|
||||
status = wuffs_gif__decoder__decode_frame(
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, g_work_slice_u8, NULL);
|
||||
if ((q == 1) && (i == 1)) {
|
||||
if (status.repr != wuffs_gif__error__bad_palette) {
|
||||
RETURN_FAIL("q=%d: i=%d: decode_frame: have \"%s\", want \"%s\"", q,
|
||||
@@ -818,7 +817,7 @@ const char* //
|
||||
test_wuffs_gif_decode_background_color() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-background-color.gif"));
|
||||
@@ -857,7 +856,7 @@ const char* //
|
||||
test_wuffs_gif_decode_first_frame_is_opaque() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-frame-out-of-bounds.gif"));
|
||||
@@ -895,7 +894,7 @@ 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,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-frame-out-of-bounds.gif"));
|
||||
@@ -941,7 +940,7 @@ test_wuffs_gif_decode_frame_out_of_bounds() {
|
||||
wuffs_base__pixel_config__pixel_subsampling(&ic.pixcfg).repr, 5, 5);
|
||||
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
|
||||
status = wuffs_base__pixel_buffer__set_from_slice(&pb, &five_by_five,
|
||||
global_pixel_slice);
|
||||
g_pixel_slice_u8);
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
RETURN_FAIL("q=%d: set_from_slice: \"%s\"", q, status.repr);
|
||||
}
|
||||
@@ -1010,7 +1009,7 @@ test_wuffs_gif_decode_frame_out_of_bounds() {
|
||||
|
||||
status = wuffs_gif__decoder__decode_frame(&dec, &pb, &src,
|
||||
WUFFS_BASE__PIXEL_BLEND__SRC,
|
||||
global_work_slice, NULL);
|
||||
g_work_slice_u8, NULL);
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
RETURN_FAIL("q=%d: decode_frame #%" PRIu32 ": \"%s\"", q, i,
|
||||
status.repr);
|
||||
@@ -1065,7 +1064,7 @@ const char* //
|
||||
test_wuffs_gif_decode_zero_width_frame() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-zero-width-frame.gif"));
|
||||
@@ -1105,13 +1104,13 @@ test_wuffs_gif_decode_zero_width_frame() {
|
||||
|
||||
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
|
||||
status = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
|
||||
global_pixel_slice);
|
||||
g_pixel_slice_u8);
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
RETURN_FAIL("q=%d: set_from_slice: \"%s\"", q, status.repr);
|
||||
}
|
||||
|
||||
wuffs_base__status have = wuffs_gif__decoder__decode_frame(
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, global_work_slice, NULL);
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, g_work_slice_u8, NULL);
|
||||
if (have.repr != want) {
|
||||
RETURN_FAIL("q=%d: decode_frame: have \"%s\", want \"%s\"", q, have.repr,
|
||||
want);
|
||||
@@ -1213,7 +1212,7 @@ 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,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/bricks-dither.png"));
|
||||
|
||||
@@ -1237,7 +1236,7 @@ const char* //
|
||||
test_wuffs_gif_decode_interlaced_truncated() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/hippopotamus.interlaced.truncated.gif"));
|
||||
@@ -1269,7 +1268,7 @@ test_wuffs_gif_decode_interlaced_truncated() {
|
||||
|
||||
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
|
||||
CHECK_STATUS("set_from_slice", wuffs_base__pixel_buffer__set_from_slice(
|
||||
&pb, &ic.pixcfg, global_pixel_slice));
|
||||
&pb, &ic.pixcfg, g_pixel_slice_u8));
|
||||
uint8_t* pixel_ptr = wuffs_base__pixel_buffer__plane(&pb, 0).ptr;
|
||||
memset(pixel_ptr, 0xEE, num_pixel_indexes);
|
||||
|
||||
@@ -1279,7 +1278,7 @@ test_wuffs_gif_decode_interlaced_truncated() {
|
||||
}
|
||||
|
||||
wuffs_base__status status = wuffs_gif__decoder__decode_frame(
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, global_work_slice, NULL);
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, g_work_slice_u8, NULL);
|
||||
if (status.repr != wuffs_base__suspension__short_read) {
|
||||
RETURN_FAIL("decode_frame: have \"%s\", want \"%s\"", status.repr,
|
||||
wuffs_base__suspension__short_read);
|
||||
@@ -1300,9 +1299,10 @@ test_wuffs_gif_decode_interlaced_truncated() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* do_test_wuffs_gif_decode_metadata(bool full) {
|
||||
const char* //
|
||||
do_test_wuffs_gif_decode_metadata(bool full) {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, full ? "test/data/artificial/gif-metadata-full.gif"
|
||||
@@ -1472,7 +1472,7 @@ const char* //
|
||||
test_wuffs_gif_decode_missing_two_src_bytes() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/pjw-thumbnail.gif"));
|
||||
|
||||
@@ -1490,7 +1490,7 @@ const char* //
|
||||
test_wuffs_gif_decode_multiple_graphic_controls() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(
|
||||
&src, "test/data/artificial/gif-multiple-graphic-controls.gif"));
|
||||
@@ -1517,7 +1517,7 @@ const char* //
|
||||
test_wuffs_gif_decode_multiple_loop_counts() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-multiple-loop-counts.gif"));
|
||||
@@ -1579,7 +1579,7 @@ const char* //
|
||||
test_wuffs_gif_decode_pixel_data_none() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/artificial/gif-pixel-data-none.gif"));
|
||||
|
||||
@@ -1591,7 +1591,7 @@ const char* //
|
||||
test_wuffs_gif_decode_pixel_data_not_enough() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-pixel-data-not-enough.gif"));
|
||||
@@ -1604,7 +1604,7 @@ const char* //
|
||||
test_wuffs_gif_decode_pixel_data_too_much_sans_quirk() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-pixel-data-too-much.gif"));
|
||||
@@ -1617,7 +1617,7 @@ const char* //
|
||||
test_wuffs_gif_decode_pixel_data_too_much_with_quirk() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-pixel-data-too-much.gif"));
|
||||
@@ -1630,7 +1630,7 @@ const char* //
|
||||
test_wuffs_gif_frame_dirty_rect() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/hippopotamus.interlaced.gif"));
|
||||
|
||||
@@ -1646,7 +1646,7 @@ test_wuffs_gif_frame_dirty_rect() {
|
||||
|
||||
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
|
||||
CHECK_STATUS("set_from_slice", wuffs_base__pixel_buffer__set_from_slice(
|
||||
&pb, &ic.pixcfg, global_pixel_slice));
|
||||
&pb, &ic.pixcfg, g_pixel_slice_u8));
|
||||
|
||||
// The hippopotamus.interlaced.gif image is 28 pixels high. As we decode rows
|
||||
// of pixels, interlacing means that we decode rows 0, 8, 16, 24, 4, 12, 20,
|
||||
@@ -1661,8 +1661,8 @@ test_wuffs_gif_frame_dirty_rect() {
|
||||
wuffs_base__io_buffer limited_src = make_limited_reader(src, 1);
|
||||
|
||||
wuffs_base__status status = wuffs_gif__decoder__decode_frame(
|
||||
&dec, &pb, &limited_src, WUFFS_BASE__PIXEL_BLEND__SRC,
|
||||
global_work_slice, NULL);
|
||||
&dec, &pb, &limited_src, WUFFS_BASE__PIXEL_BLEND__SRC, g_work_slice_u8,
|
||||
NULL);
|
||||
src.meta.ri += limited_src.meta.ri;
|
||||
|
||||
wuffs_base__rect_ie_u32 r = wuffs_gif__decoder__frame_dirty_rect(&dec);
|
||||
@@ -1685,9 +1685,10 @@ test_wuffs_gif_frame_dirty_rect() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* 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,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/animated-red-blue.gif"));
|
||||
|
||||
@@ -1704,7 +1705,7 @@ const char* do_test_wuffs_gif_num_decoded(bool frame_config) {
|
||||
wuffs_gif__decoder__decode_image_config(&dec, &ic, &src));
|
||||
|
||||
CHECK_STATUS("set_from_slice", wuffs_base__pixel_buffer__set_from_slice(
|
||||
&pb, &ic.pixcfg, global_pixel_slice));
|
||||
&pb, &ic.pixcfg, g_pixel_slice_u8));
|
||||
}
|
||||
|
||||
const char* method = frame_config ? "decode_frame_config" : "decode_frame";
|
||||
@@ -1728,9 +1729,8 @@ const char* do_test_wuffs_gif_num_decoded(bool frame_config) {
|
||||
if (frame_config) {
|
||||
status = wuffs_gif__decoder__decode_frame_config(&dec, NULL, &src);
|
||||
} else {
|
||||
status = wuffs_gif__decoder__decode_frame(&dec, &pb, &src,
|
||||
WUFFS_BASE__PIXEL_BLEND__SRC,
|
||||
global_work_slice, NULL);
|
||||
status = wuffs_gif__decoder__decode_frame(
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, g_work_slice_u8, NULL);
|
||||
}
|
||||
|
||||
if (wuffs_base__status__is_ok(&status)) {
|
||||
@@ -1761,9 +1761,10 @@ test_wuffs_gif_num_decoded_frames() {
|
||||
return do_test_wuffs_gif_num_decoded(false);
|
||||
}
|
||||
|
||||
const char* 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,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/animated-red-blue.gif"));
|
||||
|
||||
@@ -1929,7 +1930,7 @@ const char* //
|
||||
test_wuffs_gif_small_frame_interlaced() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-small-frame-interlaced.gif"));
|
||||
@@ -1954,7 +1955,7 @@ test_wuffs_gif_small_frame_interlaced() {
|
||||
|
||||
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
|
||||
CHECK_STATUS("set_from_slice", wuffs_base__pixel_buffer__set_from_slice(
|
||||
&pb, &ic.pixcfg, global_pixel_slice));
|
||||
&pb, &ic.pixcfg, g_pixel_slice_u8));
|
||||
|
||||
wuffs_base__frame_config fc;
|
||||
CHECK_STATUS("decode_frame_config",
|
||||
@@ -1969,7 +1970,7 @@ test_wuffs_gif_small_frame_interlaced() {
|
||||
CHECK_STATUS("decode_frame",
|
||||
wuffs_gif__decoder__decode_frame(&dec, &pb, &src,
|
||||
WUFFS_BASE__PIXEL_BLEND__SRC,
|
||||
global_work_slice, NULL));
|
||||
g_work_slice_u8, NULL));
|
||||
|
||||
wuffs_base__rect_ie_u32 dr = wuffs_gif__decoder__frame_dirty_rect(&dec);
|
||||
if (dr.max_excl_y != 3) {
|
||||
@@ -1999,15 +2000,16 @@ test_wuffs_gif_sizeof() {
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
const char* 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,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, filename));
|
||||
|
||||
src.meta.ri = 0;
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
wuffs_gif_decode(&have, 0,
|
||||
@@ -2017,7 +2019,7 @@ const char* do_test_mimic_gif_decode(const char* filename) {
|
||||
|
||||
src.meta.ri = 0;
|
||||
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
|
||||
.data = global_want_slice,
|
||||
.data = g_want_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
mimic_gif_decode(&want, 0,
|
||||
@@ -2125,17 +2127,17 @@ do_bench_gif_decode(const char* (*decode_func)(wuffs_base__io_buffer*,
|
||||
wuffs_base__pixel_format pixfmt,
|
||||
uint64_t iters_unscaled) {
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, filename));
|
||||
|
||||
bench_start();
|
||||
uint64_t n_bytes = 0;
|
||||
uint64_t i;
|
||||
uint64_t iters = iters_unscaled * flags.iterscale;
|
||||
uint64_t iters = iters_unscaled * g_flags.iterscale;
|
||||
for (i = 0; i < iters; i++) {
|
||||
have.meta.wi = 0;
|
||||
src.meta.ri = 0;
|
||||
@@ -2354,7 +2356,7 @@ bench_mimic_gif_decode_anim_screencap() {
|
||||
|
||||
// ---------------- Manifest
|
||||
|
||||
proc tests[] = {
|
||||
proc g_tests[] = {
|
||||
|
||||
// These basic tests are really testing the Wuffs compiler. They aren't
|
||||
// specific to the std/gif code, but putting them here is as good as any
|
||||
@@ -2428,7 +2430,7 @@ proc tests[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
proc benches[] = {
|
||||
proc g_benches[] = {
|
||||
|
||||
bench_wuffs_gif_decode_1k_bw,
|
||||
bench_wuffs_gif_decode_1k_color_full_init,
|
||||
@@ -2460,6 +2462,6 @@ proc benches[] = {
|
||||
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/gif";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
g_proc_package_name = "std/gif";
|
||||
return test_main(argc, argv, g_tests, g_benches);
|
||||
}
|
||||
+19
-19
@@ -71,12 +71,12 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
|
||||
|
||||
// ---------------- Golden Tests
|
||||
|
||||
golden_test gzip_midsummer_gt = {
|
||||
golden_test g_gzip_midsummer_gt = {
|
||||
.want_filename = "test/data/midsummer.txt",
|
||||
.src_filename = "test/data/midsummer.txt.gz",
|
||||
};
|
||||
|
||||
golden_test gzip_pi_gt = {
|
||||
golden_test g_gzip_pi_gt = {
|
||||
.want_filename = "test/data/pi.txt",
|
||||
.src_filename = "test/data/pi.txt.gz",
|
||||
};
|
||||
@@ -112,7 +112,7 @@ wuffs_gzip_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer limited_src = make_limited_reader(*src, rlimit);
|
||||
|
||||
wuffs_base__status status = wuffs_gzip__decoder__transform_io(
|
||||
&dec, &limited_dst, &limited_src, global_work_slice);
|
||||
&dec, &limited_dst, &limited_src, g_work_slice_u8);
|
||||
|
||||
dst->meta.wi += limited_dst.meta.wi;
|
||||
src->meta.ri += limited_src.meta.ri;
|
||||
@@ -130,13 +130,13 @@ wuffs_gzip_decode(wuffs_base__io_buffer* dst,
|
||||
const char* //
|
||||
do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) {
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
|
||||
CHECK_STRING(read_file(&src, gzip_midsummer_gt.src_filename));
|
||||
CHECK_STRING(read_file(&src, g_gzip_midsummer_gt.src_filename));
|
||||
|
||||
// Flip a bit in the gzip checksum, which is in the last 8 bytes of the file.
|
||||
if (src.meta.wi < 8) {
|
||||
@@ -180,7 +180,7 @@ do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) {
|
||||
|
||||
wuffs_base__io_buffer limited_src = make_limited_reader(src, rlimit);
|
||||
wuffs_base__status have_z = wuffs_gzip__decoder__transform_io(
|
||||
&dec, &have, &limited_src, global_work_slice);
|
||||
&dec, &have, &limited_src, g_work_slice_u8);
|
||||
src.meta.ri += limited_src.meta.ri;
|
||||
if (have_z.repr != want_z) {
|
||||
RETURN_FAIL("end_limit=%d: have \"%s\", want \"%s\"", end_limit,
|
||||
@@ -218,14 +218,14 @@ test_wuffs_gzip_checksum_verify_good() {
|
||||
const char* //
|
||||
test_wuffs_gzip_decode_midsummer() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_gzip_decode, &gzip_midsummer_gt, UINT64_MAX,
|
||||
return do_test_io_buffers(wuffs_gzip_decode, &g_gzip_midsummer_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_gzip_decode_pi() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_gzip_decode, &gzip_pi_gt, UINT64_MAX,
|
||||
return do_test_io_buffers(wuffs_gzip_decode, &g_gzip_pi_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
@@ -236,14 +236,14 @@ test_wuffs_gzip_decode_pi() {
|
||||
const char* //
|
||||
test_mimic_gzip_decode_midsummer() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_gzip_decode, &gzip_midsummer_gt, UINT64_MAX,
|
||||
return do_test_io_buffers(mimic_gzip_decode, &g_gzip_midsummer_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_mimic_gzip_decode_pi() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_gzip_decode, &gzip_pi_gt, UINT64_MAX,
|
||||
return do_test_io_buffers(mimic_gzip_decode, &g_gzip_pi_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
@@ -256,7 +256,7 @@ bench_wuffs_gzip_decode_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_gzip_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
tcounter_dst, &gzip_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
tcounter_dst, &g_gzip_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
}
|
||||
|
||||
const char* //
|
||||
@@ -264,7 +264,7 @@ bench_wuffs_gzip_decode_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_gzip_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
tcounter_dst, &gzip_pi_gt, UINT64_MAX, UINT64_MAX, 30);
|
||||
tcounter_dst, &g_gzip_pi_gt, UINT64_MAX, UINT64_MAX, 30);
|
||||
}
|
||||
|
||||
// ---------------- Mimic Benches
|
||||
@@ -275,13 +275,13 @@ const char* //
|
||||
bench_mimic_gzip_decode_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_gzip_decode, 0, tcounter_dst,
|
||||
&gzip_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
&g_gzip_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
}
|
||||
|
||||
const char* //
|
||||
bench_mimic_gzip_decode_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_gzip_decode, 0, tcounter_dst, &gzip_pi_gt,
|
||||
return do_bench_io_buffers(mimic_gzip_decode, 0, tcounter_dst, &g_gzip_pi_gt,
|
||||
UINT64_MAX, UINT64_MAX, 30);
|
||||
}
|
||||
|
||||
@@ -292,7 +292,7 @@ bench_mimic_gzip_decode_100k() {
|
||||
// Note that the gzip mimic tests and benches don't work with
|
||||
// WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB.
|
||||
|
||||
proc tests[] = {
|
||||
proc g_tests[] = {
|
||||
|
||||
test_wuffs_gzip_checksum_ignore,
|
||||
test_wuffs_gzip_checksum_verify_bad0,
|
||||
@@ -312,7 +312,7 @@ proc tests[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
proc benches[] = {
|
||||
proc g_benches[] = {
|
||||
|
||||
bench_wuffs_gzip_decode_10k,
|
||||
bench_wuffs_gzip_decode_100k,
|
||||
@@ -329,6 +329,6 @@ proc benches[] = {
|
||||
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/gzip";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
g_proc_package_name = "std/gzip";
|
||||
return test_main(argc, argv, g_tests, g_benches);
|
||||
}
|
||||
+77
-78
@@ -354,43 +354,43 @@ test_strconv_hexadecimal() {
|
||||
|
||||
{
|
||||
const char* str = "6A6b7"; // The "7" should be ignored.
|
||||
wuffs_base__slice_u8 dst = global_have_slice;
|
||||
wuffs_base__slice_u8 dst = g_have_slice_u8;
|
||||
wuffs_base__slice_u8 src =
|
||||
wuffs_base__make_slice_u8((void*)str, strlen(str));
|
||||
size_t have = wuffs_base__hexadecimal__decode2(dst, src);
|
||||
if (have != 2) {
|
||||
RETURN_FAIL("decode2: have %zu, want 2", have);
|
||||
}
|
||||
if (global_have_array[0] != 0x6A) {
|
||||
if (g_have_array_u8[0] != 0x6A) {
|
||||
RETURN_FAIL("decode2: dst[0]: have 0x%02X, want 0x6A",
|
||||
(int)(global_have_array[0]));
|
||||
(int)(g_have_array_u8[0]));
|
||||
}
|
||||
if (global_have_array[1] != 0x6B) {
|
||||
if (g_have_array_u8[1] != 0x6B) {
|
||||
RETURN_FAIL("decode2: dst[1]: have 0x%02X, want 0x6B",
|
||||
(int)(global_have_array[1]));
|
||||
(int)(g_have_array_u8[1]));
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
const char* str = "\\xa9\\x00\\xFe";
|
||||
wuffs_base__slice_u8 dst = global_have_slice;
|
||||
wuffs_base__slice_u8 dst = g_have_slice_u8;
|
||||
wuffs_base__slice_u8 src =
|
||||
wuffs_base__make_slice_u8((void*)str, strlen(str));
|
||||
size_t have = wuffs_base__hexadecimal__decode4(dst, src);
|
||||
if (have != 3) {
|
||||
RETURN_FAIL("decode4: have %zu, want 3", have);
|
||||
}
|
||||
if (global_have_array[0] != 0xA9) {
|
||||
if (g_have_array_u8[0] != 0xA9) {
|
||||
RETURN_FAIL("decode4: dst[0]: have 0x%02X, want 0xA9",
|
||||
(int)(global_have_array[0]));
|
||||
(int)(g_have_array_u8[0]));
|
||||
}
|
||||
if (global_have_array[1] != 0x00) {
|
||||
if (g_have_array_u8[1] != 0x00) {
|
||||
RETURN_FAIL("decode4: dst[1]: have 0x%02X, want 0x00",
|
||||
(int)(global_have_array[1]));
|
||||
(int)(g_have_array_u8[1]));
|
||||
}
|
||||
if (global_have_array[2] != 0xFE) {
|
||||
if (g_have_array_u8[2] != 0xFE) {
|
||||
RETURN_FAIL("decode4: dst[2]: have 0x%02X, want 0xFE",
|
||||
(int)(global_have_array[2]));
|
||||
(int)(g_have_array_u8[2]));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -761,33 +761,33 @@ test_strconv_utf_8_next() {
|
||||
|
||||
// ---------------- Golden Tests
|
||||
|
||||
golden_test json_australian_abc_gt = {
|
||||
golden_test g_json_australian_abc_gt = {
|
||||
.want_filename = "test/data/australian-abc-local-stations.tokens",
|
||||
.src_filename = "test/data/australian-abc-local-stations.json",
|
||||
};
|
||||
|
||||
golden_test json_file_sizes_gt = {
|
||||
golden_test g_json_file_sizes_gt = {
|
||||
.src_filename = "test/data/file-sizes.json",
|
||||
};
|
||||
|
||||
golden_test json_github_tags_gt = {
|
||||
golden_test g_json_github_tags_gt = {
|
||||
.src_filename = "test/data/github-tags.json",
|
||||
};
|
||||
|
||||
golden_test json_json_things_unformatted_gt = {
|
||||
golden_test g_json_json_things_unformatted_gt = {
|
||||
.want_filename = "test/data/json-things.unformatted.tokens",
|
||||
.src_filename = "test/data/json-things.unformatted.json",
|
||||
};
|
||||
|
||||
golden_test json_nobel_prizes_gt = {
|
||||
.src_filename = "test/data/nobel-prizes.json",
|
||||
};
|
||||
|
||||
golden_test json_json_quirks_gt = {
|
||||
golden_test g_json_json_quirks_gt = {
|
||||
.want_filename = "test/data/json-quirks.tokens",
|
||||
.src_filename = "test/data/json-quirks.json",
|
||||
};
|
||||
|
||||
golden_test g_json_nobel_prizes_gt = {
|
||||
.src_filename = "test/data/nobel-prizes.json",
|
||||
};
|
||||
|
||||
// ---------------- JSON Tests
|
||||
|
||||
const char* //
|
||||
@@ -802,7 +802,7 @@ test_wuffs_json_decode_interface() {
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
CHECK_STRING(do_test__wuffs_base__token_decoder(
|
||||
wuffs_json__decoder__upcast_as__wuffs_base__token_decoder(&dec),
|
||||
&json_json_things_unformatted_gt));
|
||||
&g_json_json_things_unformatted_gt));
|
||||
}
|
||||
|
||||
{
|
||||
@@ -813,7 +813,7 @@ test_wuffs_json_decode_interface() {
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
CHECK_STRING(do_test__wuffs_base__token_decoder(
|
||||
wuffs_json__decoder__upcast_as__wuffs_base__token_decoder(&dec),
|
||||
&json_australian_abc_gt));
|
||||
&g_json_australian_abc_gt));
|
||||
}
|
||||
|
||||
{
|
||||
@@ -848,7 +848,7 @@ test_wuffs_json_decode_interface() {
|
||||
}
|
||||
CHECK_STRING(do_test__wuffs_base__token_decoder(
|
||||
wuffs_json__decoder__upcast_as__wuffs_base__token_decoder(&dec),
|
||||
&json_json_quirks_gt));
|
||||
&g_json_json_quirks_gt));
|
||||
}
|
||||
|
||||
return NULL;
|
||||
@@ -871,7 +871,7 @@ wuffs_json_decode(wuffs_base__token_buffer* tok,
|
||||
wuffs_base__io_buffer limited_src = make_limited_reader(*src, rlimit);
|
||||
|
||||
wuffs_base__status status = wuffs_json__decoder__decode_tokens(
|
||||
&dec, &limited_tok, &limited_src, global_work_slice);
|
||||
&dec, &limited_tok, &limited_src, g_work_slice_u8);
|
||||
|
||||
tok->meta.wi += limited_tok.meta.wi;
|
||||
src->meta.ri += limited_src.meta.ri;
|
||||
@@ -902,17 +902,17 @@ test_wuffs_json_decode_end_of_data() {
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
|
||||
wuffs_base__token_buffer tok =
|
||||
wuffs_base__make_token_buffer_writer(global_have_token_slice);
|
||||
wuffs_base__make_token_buffer_writer(g_have_slice_token);
|
||||
wuffs_base__io_buffer src = wuffs_base__make_io_buffer_reader(
|
||||
wuffs_base__make_slice_u8(src_ptr, src_len), true);
|
||||
CHECK_STATUS("decode_tokens", wuffs_json__decoder__decode_tokens(
|
||||
&dec, &tok, &src, global_work_slice));
|
||||
&dec, &tok, &src, g_work_slice_u8));
|
||||
if (src.meta.ri != 3) {
|
||||
RETURN_FAIL("src.meta.ri: have %zu, want 3", src.meta.ri);
|
||||
}
|
||||
|
||||
const char* have =
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, global_work_slice)
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8)
|
||||
.repr;
|
||||
if (have != wuffs_base__note__end_of_data) {
|
||||
RETURN_FAIL("decode_tokens: have \"%s\", want \"%s\"", have,
|
||||
@@ -1014,11 +1014,11 @@ test_wuffs_json_decode_long_numbers() {
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
|
||||
wuffs_base__token_buffer tok =
|
||||
wuffs_base__make_token_buffer_writer(global_have_token_slice);
|
||||
wuffs_base__make_token_buffer_writer(g_have_slice_token);
|
||||
wuffs_base__io_buffer src =
|
||||
wuffs_base__make_io_buffer_reader(src_data, closed != 0);
|
||||
const char* have = wuffs_json__decoder__decode_tokens(&dec, &tok, &src,
|
||||
global_work_slice)
|
||||
g_work_slice_u8)
|
||||
.repr;
|
||||
|
||||
size_t total_length = 0;
|
||||
@@ -1143,7 +1143,7 @@ test_wuffs_json_decode_prior_valid_utf_8() {
|
||||
// mark, where prefix and suffix are the number of 'p's and 's's and
|
||||
// test_cases[tc] is the "MIDDLE".
|
||||
wuffs_base__slice_u8 src_data = ((wuffs_base__slice_u8){
|
||||
.ptr = global_src_array,
|
||||
.ptr = &g_src_array_u8[0],
|
||||
.len = 1 + prefix + n + suffix,
|
||||
});
|
||||
if (src_data.len > IO_BUFFER_ARRAY_SIZE) {
|
||||
@@ -1160,11 +1160,10 @@ test_wuffs_json_decode_prior_valid_utf_8() {
|
||||
&dec, sizeof dec, WUFFS_VERSION, 0));
|
||||
|
||||
wuffs_base__token_buffer tok =
|
||||
wuffs_base__make_token_buffer_writer(global_have_token_slice);
|
||||
wuffs_base__make_token_buffer_writer(g_have_slice_token);
|
||||
wuffs_base__io_buffer src =
|
||||
wuffs_base__make_io_buffer_reader(src_data, closed != 0);
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src,
|
||||
global_work_slice);
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8);
|
||||
|
||||
size_t have = 0;
|
||||
while (tok.meta.ri < tok.meta.wi) {
|
||||
@@ -1254,15 +1253,15 @@ test_wuffs_json_decode_quirk_allow_backslash_etc() {
|
||||
wuffs_json__decoder__set_quirk_enabled(&dec, test_cases[tc].quirk, q);
|
||||
|
||||
wuffs_base__token_buffer tok =
|
||||
wuffs_base__make_token_buffer_writer(global_have_token_slice);
|
||||
wuffs_base__make_token_buffer_writer(g_have_slice_token);
|
||||
wuffs_base__io_buffer src = wuffs_base__make_io_buffer_reader(
|
||||
wuffs_base__make_slice_u8((void*)(test_cases[tc].str),
|
||||
strlen(test_cases[tc].str)),
|
||||
true);
|
||||
|
||||
const char* have_status_repr = wuffs_json__decoder__decode_tokens(
|
||||
&dec, &tok, &src, global_work_slice)
|
||||
.repr;
|
||||
const char* have_status_repr =
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8)
|
||||
.repr;
|
||||
const char* want_status_repr =
|
||||
q ? NULL : wuffs_json__error__bad_backslash_escape;
|
||||
if (have_status_repr != want_status_repr) {
|
||||
@@ -1329,13 +1328,13 @@ test_wuffs_json_decode_quirk_allow_backslash_x() {
|
||||
&dec, WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X, true);
|
||||
|
||||
wuffs_base__token_buffer tok =
|
||||
wuffs_base__make_token_buffer_writer(global_have_token_slice);
|
||||
wuffs_base__make_token_buffer_writer(g_have_slice_token);
|
||||
wuffs_base__slice_u8 src_slice = wuffs_base__make_slice_u8(
|
||||
(void*)(test_cases[tc].str), strlen(test_cases[tc].str));
|
||||
wuffs_base__io_buffer src =
|
||||
wuffs_base__make_io_buffer_reader(src_slice, true);
|
||||
const char* have_status_repr =
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, global_work_slice)
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8)
|
||||
.repr;
|
||||
if (have_status_repr != test_cases[tc].want_status_repr) {
|
||||
RETURN_FAIL("tc=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
|
||||
@@ -1404,14 +1403,14 @@ test_wuffs_json_decode_quirk_allow_extra_comma() {
|
||||
&dec, WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA, q & 1);
|
||||
|
||||
wuffs_base__token_buffer tok =
|
||||
wuffs_base__make_token_buffer_writer(global_have_token_slice);
|
||||
wuffs_base__make_token_buffer_writer(g_have_slice_token);
|
||||
wuffs_base__io_buffer src = wuffs_base__make_io_buffer_reader(
|
||||
wuffs_base__make_slice_u8((void*)(test_cases[tc].str),
|
||||
strlen(test_cases[tc].str)),
|
||||
true);
|
||||
const char* have = wuffs_json__decoder__decode_tokens(&dec, &tok, &src,
|
||||
global_work_slice)
|
||||
.repr;
|
||||
const char* have =
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8)
|
||||
.repr;
|
||||
const char* want =
|
||||
(test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input;
|
||||
if (have != want) {
|
||||
@@ -1481,14 +1480,14 @@ test_wuffs_json_decode_quirk_allow_inf_nan_numbers() {
|
||||
&dec, WUFFS_JSON__QUIRK_ALLOW_INF_NAN_NUMBERS, q & 1);
|
||||
|
||||
wuffs_base__token_buffer tok =
|
||||
wuffs_base__make_token_buffer_writer(global_have_token_slice);
|
||||
wuffs_base__make_token_buffer_writer(g_have_slice_token);
|
||||
wuffs_base__io_buffer src = wuffs_base__make_io_buffer_reader(
|
||||
wuffs_base__make_slice_u8((void*)(test_cases[tc].str),
|
||||
strlen(test_cases[tc].str)),
|
||||
true);
|
||||
const char* have = wuffs_json__decoder__decode_tokens(&dec, &tok, &src,
|
||||
global_work_slice)
|
||||
.repr;
|
||||
const char* have =
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8)
|
||||
.repr;
|
||||
const char* want =
|
||||
(test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input;
|
||||
if (have != want) {
|
||||
@@ -1554,14 +1553,14 @@ test_wuffs_json_decode_quirk_allow_comment_etc() {
|
||||
&dec, WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE, q & 2);
|
||||
|
||||
wuffs_base__token_buffer tok =
|
||||
wuffs_base__make_token_buffer_writer(global_have_token_slice);
|
||||
wuffs_base__make_token_buffer_writer(g_have_slice_token);
|
||||
wuffs_base__io_buffer src = wuffs_base__make_io_buffer_reader(
|
||||
wuffs_base__make_slice_u8((void*)(test_cases[tc].str),
|
||||
strlen(test_cases[tc].str)),
|
||||
true);
|
||||
const char* have = wuffs_json__decoder__decode_tokens(&dec, &tok, &src,
|
||||
global_work_slice)
|
||||
.repr;
|
||||
const char* have =
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8)
|
||||
.repr;
|
||||
const char* want =
|
||||
(test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input;
|
||||
if (have != want) {
|
||||
@@ -1633,14 +1632,14 @@ test_wuffs_json_decode_quirk_allow_leading_etc() {
|
||||
&dec, WUFFS_JSON__QUIRK_ALLOW_LEADING_UNICODE_BYTE_ORDER_MARK, q & 2);
|
||||
|
||||
wuffs_base__token_buffer tok =
|
||||
wuffs_base__make_token_buffer_writer(global_have_token_slice);
|
||||
wuffs_base__make_token_buffer_writer(g_have_slice_token);
|
||||
wuffs_base__io_buffer src = wuffs_base__make_io_buffer_reader(
|
||||
wuffs_base__make_slice_u8((void*)(test_cases[tc].str),
|
||||
strlen(test_cases[tc].str)),
|
||||
true);
|
||||
const char* have = wuffs_json__decoder__decode_tokens(&dec, &tok, &src,
|
||||
global_work_slice)
|
||||
.repr;
|
||||
const char* have =
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8)
|
||||
.repr;
|
||||
const char* want =
|
||||
(test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input;
|
||||
if (have != want) {
|
||||
@@ -1712,14 +1711,14 @@ test_wuffs_json_decode_quirk_allow_trailing_etc() {
|
||||
&dec, WUFFS_JSON__QUIRK_ALLOW_TRAILING_NEW_LINE, q & 1);
|
||||
|
||||
wuffs_base__token_buffer tok =
|
||||
wuffs_base__make_token_buffer_writer(global_have_token_slice);
|
||||
wuffs_base__make_token_buffer_writer(g_have_slice_token);
|
||||
wuffs_base__io_buffer src = wuffs_base__make_io_buffer_reader(
|
||||
wuffs_base__make_slice_u8((void*)(test_cases[tc].str),
|
||||
strlen(test_cases[tc].str)),
|
||||
true);
|
||||
const char* have = wuffs_json__decoder__decode_tokens(&dec, &tok, &src,
|
||||
global_work_slice)
|
||||
.repr;
|
||||
const char* have =
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8)
|
||||
.repr;
|
||||
const char* want =
|
||||
(test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input;
|
||||
if (have != want) {
|
||||
@@ -1810,15 +1809,15 @@ test_wuffs_json_decode_quirk_replace_invalid_unicode() {
|
||||
&dec, WUFFS_JSON__QUIRK_REPLACE_INVALID_UNICODE, true);
|
||||
|
||||
wuffs_base__io_buffer have =
|
||||
wuffs_base__make_io_buffer_writer(global_have_slice);
|
||||
wuffs_base__make_io_buffer_writer(g_have_slice_u8);
|
||||
wuffs_base__token_buffer tok =
|
||||
wuffs_base__make_token_buffer_writer(global_have_token_slice);
|
||||
wuffs_base__make_token_buffer_writer(g_have_slice_token);
|
||||
wuffs_base__io_buffer src = wuffs_base__make_io_buffer_reader(
|
||||
wuffs_base__make_slice_u8((void*)(test_cases[tc].str),
|
||||
strlen(test_cases[tc].str)),
|
||||
true);
|
||||
CHECK_STATUS("decode_tokens", wuffs_json__decoder__decode_tokens(
|
||||
&dec, &tok, &src, global_work_slice));
|
||||
&dec, &tok, &src, g_work_slice_u8));
|
||||
|
||||
uint64_t src_index = 0;
|
||||
while (tok.meta.ri < tok.meta.wi) {
|
||||
@@ -1946,12 +1945,12 @@ test_wuffs_json_decode_unicode4_escapes() {
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
|
||||
wuffs_base__token_buffer tok =
|
||||
wuffs_base__make_token_buffer_writer(global_have_token_slice);
|
||||
wuffs_base__make_token_buffer_writer(g_have_slice_token);
|
||||
wuffs_base__io_buffer src = wuffs_base__make_io_buffer_reader(
|
||||
wuffs_base__make_slice_u8((void*)(test_cases[tc].str),
|
||||
strlen(test_cases[tc].str)),
|
||||
true);
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, global_work_slice);
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8);
|
||||
|
||||
uint32_t have = fail;
|
||||
uint64_t total_length = 0;
|
||||
@@ -2035,7 +2034,7 @@ test_wuffs_json_decode_src_io_buffer_length() {
|
||||
int closed;
|
||||
for (closed = 0; closed < 2; closed++) {
|
||||
wuffs_base__token_buffer tok =
|
||||
wuffs_base__make_token_buffer_writer(global_have_token_slice);
|
||||
wuffs_base__make_token_buffer_writer(g_have_slice_token);
|
||||
wuffs_base__io_buffer src =
|
||||
wuffs_base__make_io_buffer_reader(src_data, closed != 0);
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -2043,8 +2042,8 @@ test_wuffs_json_decode_src_io_buffer_length() {
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
|
||||
wuffs_base__status have = wuffs_json__decoder__decode_tokens(
|
||||
&dec, &tok, &src, global_work_slice);
|
||||
wuffs_base__status have =
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8);
|
||||
const char* want =
|
||||
(i > WUFFS_JSON__DECODER_NUMBER_LENGTH_MAX_INCL)
|
||||
? wuffs_json__error__unsupported_number_length
|
||||
@@ -2138,13 +2137,13 @@ test_wuffs_json_decode_string() {
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
|
||||
wuffs_base__token_buffer tok =
|
||||
wuffs_base__make_token_buffer_writer(global_have_token_slice);
|
||||
wuffs_base__make_token_buffer_writer(g_have_slice_token);
|
||||
wuffs_base__io_buffer src = wuffs_base__make_io_buffer_reader(
|
||||
wuffs_base__make_slice_u8((void*)(test_cases[tc].str),
|
||||
strlen(test_cases[tc].str)),
|
||||
true);
|
||||
wuffs_base__status have_status =
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, global_work_slice);
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8);
|
||||
|
||||
uint64_t total_length = 0;
|
||||
size_t i;
|
||||
@@ -2183,7 +2182,7 @@ bench_wuffs_json_decode_1k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_token_decoder(
|
||||
wuffs_json_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
tcounter_src, &json_github_tags_gt, UINT64_MAX, UINT64_MAX, 10000);
|
||||
tcounter_src, &g_json_github_tags_gt, UINT64_MAX, UINT64_MAX, 10000);
|
||||
}
|
||||
|
||||
const char* //
|
||||
@@ -2191,7 +2190,7 @@ bench_wuffs_json_decode_21k_formatted() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_token_decoder(
|
||||
wuffs_json_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
tcounter_src, &json_file_sizes_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
tcounter_src, &g_json_file_sizes_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
}
|
||||
|
||||
const char* //
|
||||
@@ -2199,7 +2198,7 @@ bench_wuffs_json_decode_26k_compact() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_token_decoder(
|
||||
wuffs_json_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
tcounter_src, &json_australian_abc_gt, UINT64_MAX, UINT64_MAX, 250);
|
||||
tcounter_src, &g_json_australian_abc_gt, UINT64_MAX, UINT64_MAX, 250);
|
||||
}
|
||||
|
||||
const char* //
|
||||
@@ -2207,7 +2206,7 @@ bench_wuffs_json_decode_217k_stringy() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_token_decoder(
|
||||
wuffs_json_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
tcounter_src, &json_nobel_prizes_gt, UINT64_MAX, UINT64_MAX, 25);
|
||||
tcounter_src, &g_json_nobel_prizes_gt, UINT64_MAX, UINT64_MAX, 25);
|
||||
}
|
||||
|
||||
// ---------------- Mimic Benches
|
||||
@@ -2220,7 +2219,7 @@ bench_wuffs_json_decode_217k_stringy() {
|
||||
|
||||
// ---------------- Manifest
|
||||
|
||||
proc tests[] = {
|
||||
proc g_tests[] = {
|
||||
|
||||
// These strconv tests are really testing the Wuffs base library. They
|
||||
// aren't specific to the std/json code, but putting them here is as good
|
||||
@@ -2258,7 +2257,7 @@ proc tests[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
proc benches[] = {
|
||||
proc g_benches[] = {
|
||||
|
||||
bench_wuffs_json_decode_1k,
|
||||
bench_wuffs_json_decode_21k_formatted,
|
||||
@@ -2276,6 +2275,6 @@ proc benches[] = {
|
||||
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/json";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
g_proc_package_name = "std/json";
|
||||
return test_main(argc, argv, g_tests, g_benches);
|
||||
}
|
||||
+24
-24
@@ -87,13 +87,13 @@ do_test_wuffs_lzw_decode(const char* src_filename,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
|
||||
.data = global_want_slice,
|
||||
.data = g_want_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
|
||||
CHECK_STRING(read_file(&src, src_filename));
|
||||
@@ -130,7 +130,7 @@ do_test_wuffs_lzw_decode(const char* src_filename,
|
||||
size_t old_ri = src.meta.ri;
|
||||
|
||||
wuffs_base__status status = wuffs_lzw__decoder__transform_io(
|
||||
&dec, &limited_have, &limited_src, global_work_slice);
|
||||
&dec, &limited_have, &limited_src, g_work_slice_u8);
|
||||
have.meta.wi += limited_have.meta.wi;
|
||||
src.meta.ri += limited_src.meta.ri;
|
||||
if (wuffs_base__status__is_ok(&status)) {
|
||||
@@ -215,10 +215,10 @@ test_wuffs_lzw_decode_output_bad() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
|
||||
// Set up src to be 20 bytes long, starting with three 8-bit literal codes
|
||||
@@ -242,7 +242,7 @@ test_wuffs_lzw_decode_output_bad() {
|
||||
wuffs_lzw__decoder__set_literal_width(&dec, 7);
|
||||
|
||||
wuffs_base__status status =
|
||||
wuffs_lzw__decoder__transform_io(&dec, &have, &src, global_work_slice);
|
||||
wuffs_lzw__decoder__transform_io(&dec, &have, &src, g_work_slice_u8);
|
||||
if (status.repr != wuffs_lzw__error__bad_code) {
|
||||
RETURN_FAIL("transform_io: have \"%s\", want \"%s\"", status.repr,
|
||||
wuffs_lzw__error__bad_code);
|
||||
@@ -262,10 +262,10 @@ test_wuffs_lzw_decode_output_empty() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
|
||||
// Set up src to be 20 bytes long, starting with the 9-bit end code 0x101.
|
||||
@@ -286,7 +286,7 @@ test_wuffs_lzw_decode_output_empty() {
|
||||
wuffs_lzw__decoder__set_literal_width(&dec, 8);
|
||||
|
||||
CHECK_STATUS("transform_io", wuffs_lzw__decoder__transform_io(
|
||||
&dec, &have, &src, global_work_slice));
|
||||
&dec, &have, &src, g_work_slice_u8));
|
||||
|
||||
if (have.meta.wi != 0) {
|
||||
RETURN_FAIL("have.meta.wi: have %d, want 0", (int)(have.meta.wi));
|
||||
@@ -309,10 +309,10 @@ do_test_wuffs_lzw_decode_width(uint32_t width,
|
||||
wuffs_lzw__decoder__set_literal_width(&dec, width);
|
||||
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
CHECK_STATUS("transform_io", wuffs_lzw__decoder__transform_io(
|
||||
&dec, &have, &src, global_work_slice));
|
||||
&dec, &have, &src, g_work_slice_u8));
|
||||
|
||||
return check_io_buffers_equal("", &have, &want);
|
||||
}
|
||||
@@ -333,14 +333,14 @@ test_wuffs_lzw_decode_width_0() {
|
||||
// 0b...._..00_0..._.... 0x000 Literal "0".
|
||||
// 0b...0_10.._...._.... 0x010 End code.
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
src.meta.wi = 2;
|
||||
src.data.ptr[0] = 0x4D;
|
||||
src.data.ptr[1] = 0x08;
|
||||
|
||||
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
|
||||
.data = global_want_slice,
|
||||
.data = g_want_slice_u8,
|
||||
});
|
||||
want.meta.wi = 7;
|
||||
want.data.ptr[0] = 0x00;
|
||||
@@ -364,14 +364,14 @@ test_wuffs_lzw_decode_width_1() {
|
||||
// 0b...._..10_0..._.... 0x100 Back-ref "01".
|
||||
// 0b...0_11.._...._.... 0x011 End code.
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
src.meta.wi = 2;
|
||||
src.data.ptr[0] = 0x12;
|
||||
src.data.ptr[1] = 0x0E;
|
||||
|
||||
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
|
||||
.data = global_want_slice,
|
||||
.data = g_want_slice_u8,
|
||||
});
|
||||
want.meta.wi = 4;
|
||||
want.data.ptr[0] = 0x00;
|
||||
@@ -387,10 +387,10 @@ test_wuffs_lzw_decode_width_1() {
|
||||
const char* //
|
||||
do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) {
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
|
||||
CHECK_STRING(read_file(&src, filename));
|
||||
@@ -406,7 +406,7 @@ do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) {
|
||||
bench_start();
|
||||
uint64_t n_bytes = 0;
|
||||
uint64_t i;
|
||||
uint64_t iters = iters_unscaled * flags.iterscale;
|
||||
uint64_t iters = iters_unscaled * g_flags.iterscale;
|
||||
for (i = 0; i < iters; i++) {
|
||||
have.meta.wi = 0;
|
||||
src.meta.ri = 1; // Skip the literal width.
|
||||
@@ -416,7 +416,7 @@ do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) {
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
CHECK_STATUS("transform_io", wuffs_lzw__decoder__transform_io(
|
||||
&dec, &have, &src, global_work_slice));
|
||||
&dec, &have, &src, g_work_slice_u8));
|
||||
n_bytes += have.meta.wi;
|
||||
}
|
||||
bench_finish(iters, n_bytes);
|
||||
@@ -437,7 +437,7 @@ bench_wuffs_lzw_decode_100k() {
|
||||
|
||||
// ---------------- Manifest
|
||||
|
||||
proc tests[] = {
|
||||
proc g_tests[] = {
|
||||
|
||||
test_wuffs_lzw_decode_bricks_dither,
|
||||
test_wuffs_lzw_decode_bricks_nodither,
|
||||
@@ -453,7 +453,7 @@ proc tests[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
proc benches[] = {
|
||||
proc g_benches[] = {
|
||||
|
||||
bench_wuffs_lzw_decode_20k,
|
||||
bench_wuffs_lzw_decode_100k,
|
||||
@@ -463,6 +463,6 @@ proc benches[] = {
|
||||
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/lzw";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
g_proc_package_name = "std/lzw";
|
||||
return test_main(argc, argv, g_tests, g_benches);
|
||||
}
|
||||
+6
-6
@@ -93,7 +93,7 @@ test_wuffs_wbmp_decode_frame_config() {
|
||||
|
||||
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/hat.wbmp"));
|
||||
CHECK_STATUS("decode_frame_config #0",
|
||||
@@ -123,7 +123,7 @@ test_wuffs_wbmp_decode_image_config() {
|
||||
|
||||
wuffs_base__image_config ic = ((wuffs_base__image_config){});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/bricks-nodither.wbmp"));
|
||||
CHECK_STATUS("decode_image_config",
|
||||
@@ -166,7 +166,7 @@ test_wuffs_wbmp_decode_image_config() {
|
||||
|
||||
// ---------------- Manifest
|
||||
|
||||
proc tests[] = {
|
||||
proc g_tests[] = {
|
||||
|
||||
test_wuffs_wbmp_decode_frame_config,
|
||||
test_wuffs_wbmp_decode_image_config,
|
||||
@@ -181,7 +181,7 @@ proc tests[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
proc benches[] = {
|
||||
proc g_benches[] = {
|
||||
|
||||
// No WBMP benches.
|
||||
|
||||
@@ -196,6 +196,6 @@ proc benches[] = {
|
||||
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/wbmp";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
g_proc_package_name = "std/wbmp";
|
||||
return test_main(argc, argv, g_tests, g_benches);
|
||||
}
|
||||
+37
-37
@@ -71,26 +71,26 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
|
||||
|
||||
// ---------------- Golden Tests
|
||||
|
||||
golden_test zlib_midsummer_gt = {
|
||||
golden_test g_zlib_midsummer_gt = {
|
||||
.want_filename = "test/data/midsummer.txt",
|
||||
.src_filename = "test/data/midsummer.txt.zlib",
|
||||
};
|
||||
|
||||
golden_test zlib_pi_gt = {
|
||||
golden_test g_zlib_pi_gt = {
|
||||
.want_filename = "test/data/pi.txt",
|
||||
.src_filename = "test/data/pi.txt.zlib",
|
||||
};
|
||||
|
||||
// This dictionary-using zlib-encoded data comes from
|
||||
// https://play.golang.org/p/Jh9Wyp6PLID, also mentioned in the RAC spec.
|
||||
const char* zlib_sheep_src_ptr =
|
||||
const char* g_zlib_sheep_src_ptr =
|
||||
"\x78\xf9\x0b\xe0\x02\x6e\x0a\x29\xcf\x87\x31\x01\x01\x00\x00\xff\xff\x18"
|
||||
"\x0c\x03\xa8";
|
||||
const size_t zlib_sheep_src_len = 21;
|
||||
const char* zlib_sheep_dict_ptr = " sheep.\n";
|
||||
const size_t zlib_sheep_dict_len = 8;
|
||||
const char* zlib_sheep_want_ptr = "Two sheep.\n";
|
||||
const size_t zlib_sheep_want_len = 11;
|
||||
const size_t g_zlib_sheep_src_len = 21;
|
||||
const char* g_zlib_sheep_dict_ptr = " sheep.\n";
|
||||
const size_t g_zlib_sheep_dict_len = 8;
|
||||
const char* g_zlib_sheep_want_ptr = "Two sheep.\n";
|
||||
const size_t g_zlib_sheep_want_len = 11;
|
||||
|
||||
// ---------------- Zlib Tests
|
||||
|
||||
@@ -123,7 +123,7 @@ wuffs_zlib_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer limited_src = make_limited_reader(*src, rlimit);
|
||||
|
||||
wuffs_base__status status = wuffs_zlib__decoder__transform_io(
|
||||
&dec, &limited_dst, &limited_src, global_work_slice);
|
||||
&dec, &limited_dst, &limited_src, g_work_slice_u8);
|
||||
|
||||
dst->meta.wi += limited_dst.meta.wi;
|
||||
src->meta.ri += limited_src.meta.ri;
|
||||
@@ -141,13 +141,13 @@ wuffs_zlib_decode(wuffs_base__io_buffer* dst,
|
||||
const char* //
|
||||
do_test_wuffs_zlib_checksum(bool ignore_checksum, uint32_t bad_checksum) {
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
|
||||
CHECK_STRING(read_file(&src, zlib_midsummer_gt.src_filename));
|
||||
CHECK_STRING(read_file(&src, g_zlib_midsummer_gt.src_filename));
|
||||
// Flip a bit in the zlib checksum, which is in the last 4 bytes of the file.
|
||||
if (src.meta.wi < 4) {
|
||||
RETURN_FAIL("source file was too short");
|
||||
@@ -191,7 +191,7 @@ do_test_wuffs_zlib_checksum(bool ignore_checksum, uint32_t bad_checksum) {
|
||||
wuffs_base__io_buffer limited_src = make_limited_reader(src, rlimit);
|
||||
|
||||
wuffs_base__status have_z = wuffs_zlib__decoder__transform_io(
|
||||
&dec, &have, &limited_src, global_work_slice);
|
||||
&dec, &have, &limited_src, g_work_slice_u8);
|
||||
src.meta.ri += limited_src.meta.ri;
|
||||
if (have_z.repr != want_z) {
|
||||
RETURN_FAIL("end_limit=%d: have \"%s\", want \"%s\"", end_limit,
|
||||
@@ -229,14 +229,14 @@ test_wuffs_zlib_checksum_verify_good() {
|
||||
const char* //
|
||||
test_wuffs_zlib_decode_midsummer() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_zlib_decode, &zlib_midsummer_gt, UINT64_MAX,
|
||||
return do_test_io_buffers(wuffs_zlib_decode, &g_zlib_midsummer_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_zlib_decode_pi() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_zlib_decode, &zlib_pi_gt, UINT64_MAX,
|
||||
return do_test_io_buffers(wuffs_zlib_decode, &g_zlib_pi_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
@@ -244,10 +244,10 @@ const char* //
|
||||
test_wuffs_zlib_decode_sheep() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer src =
|
||||
make_io_buffer_from_string(zlib_sheep_src_ptr, zlib_sheep_src_len);
|
||||
make_io_buffer_from_string(g_zlib_sheep_src_ptr, g_zlib_sheep_src_len);
|
||||
|
||||
wuffs_zlib__decoder dec;
|
||||
CHECK_STATUS("initialize", wuffs_zlib__decoder__initialize(
|
||||
@@ -257,7 +257,7 @@ test_wuffs_zlib_decode_sheep() {
|
||||
int i;
|
||||
for (i = 0; i < 3; i++) {
|
||||
wuffs_base__status status =
|
||||
wuffs_zlib__decoder__transform_io(&dec, &have, &src, global_work_slice);
|
||||
wuffs_zlib__decoder__transform_io(&dec, &have, &src, g_work_slice_u8);
|
||||
|
||||
if (status.repr != wuffs_zlib__note__dictionary_required) {
|
||||
RETURN_FAIL("transform_io (before dict): have \"%s\", want \"%s\"",
|
||||
@@ -274,16 +274,16 @@ test_wuffs_zlib_decode_sheep() {
|
||||
|
||||
wuffs_zlib__decoder__add_dictionary(
|
||||
&dec, ((wuffs_base__slice_u8){
|
||||
.ptr = ((uint8_t*)(zlib_sheep_dict_ptr)),
|
||||
.len = zlib_sheep_dict_len,
|
||||
.ptr = ((uint8_t*)(g_zlib_sheep_dict_ptr)),
|
||||
.len = g_zlib_sheep_dict_len,
|
||||
}));
|
||||
|
||||
CHECK_STATUS(
|
||||
"transform_io (after dict)",
|
||||
wuffs_zlib__decoder__transform_io(&dec, &have, &src, global_work_slice));
|
||||
wuffs_zlib__decoder__transform_io(&dec, &have, &src, g_work_slice_u8));
|
||||
|
||||
wuffs_base__io_buffer want =
|
||||
make_io_buffer_from_string(zlib_sheep_want_ptr, zlib_sheep_want_len);
|
||||
make_io_buffer_from_string(g_zlib_sheep_want_ptr, g_zlib_sheep_want_len);
|
||||
return check_io_buffers_equal("", &have, &want);
|
||||
}
|
||||
|
||||
@@ -294,14 +294,14 @@ test_wuffs_zlib_decode_sheep() {
|
||||
const char* //
|
||||
test_mimic_zlib_decode_midsummer() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_zlib_decode, &zlib_midsummer_gt, UINT64_MAX,
|
||||
return do_test_io_buffers(mimic_zlib_decode, &g_zlib_midsummer_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_mimic_zlib_decode_pi() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_zlib_decode, &zlib_pi_gt, UINT64_MAX,
|
||||
return do_test_io_buffers(mimic_zlib_decode, &g_zlib_pi_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
@@ -309,20 +309,20 @@ const char* //
|
||||
test_mimic_zlib_decode_sheep() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer src =
|
||||
make_io_buffer_from_string(zlib_sheep_src_ptr, zlib_sheep_src_len);
|
||||
make_io_buffer_from_string(g_zlib_sheep_src_ptr, g_zlib_sheep_src_len);
|
||||
wuffs_base__slice_u8 dict = ((wuffs_base__slice_u8){
|
||||
.ptr = ((uint8_t*)(zlib_sheep_dict_ptr)),
|
||||
.len = zlib_sheep_dict_len,
|
||||
.ptr = ((uint8_t*)(g_zlib_sheep_dict_ptr)),
|
||||
.len = g_zlib_sheep_dict_len,
|
||||
});
|
||||
const char* status = mimic_zlib_decode_with_dictionary(&have, &src, dict);
|
||||
if (status) {
|
||||
return status;
|
||||
}
|
||||
wuffs_base__io_buffer want =
|
||||
make_io_buffer_from_string(zlib_sheep_want_ptr, zlib_sheep_want_len);
|
||||
make_io_buffer_from_string(g_zlib_sheep_want_ptr, g_zlib_sheep_want_len);
|
||||
return check_io_buffers_equal("", &have, &want);
|
||||
}
|
||||
|
||||
@@ -335,7 +335,7 @@ bench_wuffs_zlib_decode_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_zlib_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
tcounter_dst, &zlib_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
tcounter_dst, &g_zlib_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
}
|
||||
|
||||
const char* //
|
||||
@@ -343,7 +343,7 @@ bench_wuffs_zlib_decode_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_zlib_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
tcounter_dst, &zlib_pi_gt, UINT64_MAX, UINT64_MAX, 30);
|
||||
tcounter_dst, &g_zlib_pi_gt, UINT64_MAX, UINT64_MAX, 30);
|
||||
}
|
||||
|
||||
// ---------------- Mimic Benches
|
||||
@@ -354,13 +354,13 @@ const char* //
|
||||
bench_mimic_zlib_decode_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_zlib_decode, 0, tcounter_dst,
|
||||
&zlib_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
&g_zlib_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
}
|
||||
|
||||
const char* //
|
||||
bench_mimic_zlib_decode_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_zlib_decode, 0, tcounter_dst, &zlib_pi_gt,
|
||||
return do_bench_io_buffers(mimic_zlib_decode, 0, tcounter_dst, &g_zlib_pi_gt,
|
||||
UINT64_MAX, UINT64_MAX, 30);
|
||||
}
|
||||
|
||||
@@ -368,7 +368,7 @@ bench_mimic_zlib_decode_100k() {
|
||||
|
||||
// ---------------- Manifest
|
||||
|
||||
proc tests[] = {
|
||||
proc g_tests[] = {
|
||||
|
||||
test_wuffs_zlib_checksum_ignore,
|
||||
test_wuffs_zlib_checksum_verify_bad0,
|
||||
@@ -390,7 +390,7 @@ proc tests[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
proc benches[] = {
|
||||
proc g_benches[] = {
|
||||
|
||||
bench_wuffs_zlib_decode_10k,
|
||||
bench_wuffs_zlib_decode_100k,
|
||||
@@ -407,6 +407,6 @@ proc benches[] = {
|
||||
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/zlib";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
g_proc_package_name = "std/zlib";
|
||||
return test_main(argc, argv, g_tests, g_benches);
|
||||
}
|
||||
+120
-117
@@ -26,67 +26,68 @@
|
||||
|
||||
#define WUFFS_TESTLIB_ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
|
||||
|
||||
uint8_t global_have_array[IO_BUFFER_ARRAY_SIZE];
|
||||
uint8_t global_want_array[IO_BUFFER_ARRAY_SIZE];
|
||||
uint8_t global_work_array[IO_BUFFER_ARRAY_SIZE];
|
||||
uint8_t global_src_array[IO_BUFFER_ARRAY_SIZE];
|
||||
uint8_t g_have_array_u8[IO_BUFFER_ARRAY_SIZE];
|
||||
uint8_t g_want_array_u8[IO_BUFFER_ARRAY_SIZE];
|
||||
uint8_t g_work_array_u8[IO_BUFFER_ARRAY_SIZE];
|
||||
uint8_t g_src_array_u8[IO_BUFFER_ARRAY_SIZE];
|
||||
|
||||
uint8_t global_pixel_array[PIXEL_BUFFER_ARRAY_SIZE];
|
||||
uint8_t g_pixel_array_u8[PIXEL_BUFFER_ARRAY_SIZE];
|
||||
|
||||
wuffs_base__token global_have_token_array[TOKEN_BUFFER_ARRAY_SIZE];
|
||||
wuffs_base__token global_want_token_array[TOKEN_BUFFER_ARRAY_SIZE];
|
||||
wuffs_base__token g_have_array_token[TOKEN_BUFFER_ARRAY_SIZE];
|
||||
wuffs_base__token g_want_array_token[TOKEN_BUFFER_ARRAY_SIZE];
|
||||
|
||||
wuffs_base__slice_u8 global_have_slice;
|
||||
wuffs_base__slice_u8 global_want_slice;
|
||||
wuffs_base__slice_u8 global_work_slice;
|
||||
wuffs_base__slice_u8 global_src_slice;
|
||||
wuffs_base__slice_u8 g_have_slice_u8;
|
||||
wuffs_base__slice_u8 g_want_slice_u8;
|
||||
wuffs_base__slice_u8 g_work_slice_u8;
|
||||
wuffs_base__slice_u8 g_src_slice_u8;
|
||||
|
||||
wuffs_base__slice_u8 global_pixel_slice;
|
||||
wuffs_base__slice_u8 g_pixel_slice_u8;
|
||||
|
||||
wuffs_base__slice_token global_have_token_slice;
|
||||
wuffs_base__slice_token global_want_token_slice;
|
||||
wuffs_base__slice_token g_have_slice_token;
|
||||
wuffs_base__slice_token g_want_slice_token;
|
||||
|
||||
void wuffs_testlib__initialize_global_xxx_slices() {
|
||||
global_have_slice = ((wuffs_base__slice_u8){
|
||||
.ptr = global_have_array,
|
||||
void //
|
||||
wuffs_testlib__initialize_global_xxx_slices() {
|
||||
g_have_slice_u8 = ((wuffs_base__slice_u8){
|
||||
.ptr = g_have_array_u8,
|
||||
.len = IO_BUFFER_ARRAY_SIZE,
|
||||
});
|
||||
global_want_slice = ((wuffs_base__slice_u8){
|
||||
.ptr = global_want_array,
|
||||
g_want_slice_u8 = ((wuffs_base__slice_u8){
|
||||
.ptr = g_want_array_u8,
|
||||
.len = IO_BUFFER_ARRAY_SIZE,
|
||||
});
|
||||
global_work_slice = ((wuffs_base__slice_u8){
|
||||
.ptr = global_work_array,
|
||||
g_work_slice_u8 = ((wuffs_base__slice_u8){
|
||||
.ptr = g_work_array_u8,
|
||||
.len = IO_BUFFER_ARRAY_SIZE,
|
||||
});
|
||||
global_src_slice = ((wuffs_base__slice_u8){
|
||||
.ptr = global_src_array,
|
||||
g_src_slice_u8 = ((wuffs_base__slice_u8){
|
||||
.ptr = g_src_array_u8,
|
||||
.len = IO_BUFFER_ARRAY_SIZE,
|
||||
});
|
||||
global_pixel_slice = ((wuffs_base__slice_u8){
|
||||
.ptr = global_pixel_array,
|
||||
g_pixel_slice_u8 = ((wuffs_base__slice_u8){
|
||||
.ptr = g_pixel_array_u8,
|
||||
.len = PIXEL_BUFFER_ARRAY_SIZE,
|
||||
});
|
||||
|
||||
global_have_token_slice = ((wuffs_base__slice_token){
|
||||
.ptr = global_have_token_array,
|
||||
g_have_slice_token = ((wuffs_base__slice_token){
|
||||
.ptr = g_have_array_token,
|
||||
.len = TOKEN_BUFFER_ARRAY_SIZE,
|
||||
});
|
||||
global_want_token_slice = ((wuffs_base__slice_token){
|
||||
.ptr = global_want_token_array,
|
||||
g_want_slice_token = ((wuffs_base__slice_token){
|
||||
.ptr = g_want_array_token,
|
||||
.len = TOKEN_BUFFER_ARRAY_SIZE,
|
||||
});
|
||||
}
|
||||
|
||||
char fail_msg[65536] = {0};
|
||||
char g_fail_msg[65536] = {0};
|
||||
|
||||
#define RETURN_FAIL(...) \
|
||||
return (snprintf(fail_msg, sizeof(fail_msg), ##__VA_ARGS__) >= 0) \
|
||||
? fail_msg \
|
||||
#define RETURN_FAIL(...) \
|
||||
return (snprintf(g_fail_msg, sizeof(g_fail_msg), ##__VA_ARGS__) >= 0) \
|
||||
? g_fail_msg \
|
||||
: "unknown failure (snprintf-related)"
|
||||
|
||||
#define INCR_FAIL(msg, ...) \
|
||||
msg += snprintf(msg, sizeof(fail_msg) - (msg - fail_msg), ##__VA_ARGS__)
|
||||
msg += snprintf(msg, sizeof(g_fail_msg) - (msg - g_fail_msg), ##__VA_ARGS__)
|
||||
|
||||
#define CHECK_STATUS(prefix, status) \
|
||||
do { \
|
||||
@@ -104,7 +105,7 @@ char fail_msg[65536] = {0};
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
int tests_run = 0;
|
||||
int g_tests_run = 0;
|
||||
|
||||
struct {
|
||||
int remaining_argc;
|
||||
@@ -114,12 +115,12 @@ struct {
|
||||
const char* focus;
|
||||
uint64_t iterscale;
|
||||
int reps;
|
||||
} flags = {0};
|
||||
} g_flags = {0};
|
||||
|
||||
const char* //
|
||||
parse_flags(int argc, char** argv) {
|
||||
flags.iterscale = 100;
|
||||
flags.reps = 5;
|
||||
g_flags.iterscale = 100;
|
||||
g_flags.reps = 5;
|
||||
|
||||
int c = (argc > 0) ? 1 : 0; // Skip argv[0], the program name.
|
||||
for (; c < argc; c++) {
|
||||
@@ -142,12 +143,12 @@ parse_flags(int argc, char** argv) {
|
||||
}
|
||||
|
||||
if (!strcmp(arg, "bench")) {
|
||||
flags.bench = true;
|
||||
g_flags.bench = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!strncmp(arg, "focus=", 6)) {
|
||||
flags.focus = arg + 6;
|
||||
g_flags.focus = arg + 6;
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -164,7 +165,7 @@ parse_flags(int argc, char** argv) {
|
||||
if ((n < 0) || (1000000 < n)) {
|
||||
return "out-of-range -iterscale=N value";
|
||||
}
|
||||
flags.iterscale = n;
|
||||
g_flags.iterscale = n;
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -181,36 +182,36 @@ parse_flags(int argc, char** argv) {
|
||||
if ((n < 0) || (1000000 < n)) {
|
||||
return "out-of-range -reps=N value";
|
||||
}
|
||||
flags.reps = n;
|
||||
g_flags.reps = n;
|
||||
continue;
|
||||
}
|
||||
|
||||
return "unrecognized flag argument";
|
||||
}
|
||||
|
||||
flags.remaining_argc = argc - c;
|
||||
flags.remaining_argv = argv + c;
|
||||
g_flags.remaining_argc = argc - c;
|
||||
g_flags.remaining_argv = argv + c;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* proc_package_name = "unknown_package_name";
|
||||
const char* proc_func_name = "unknown_func_name";
|
||||
bool in_focus = false;
|
||||
const char* g_proc_package_name = "unknown_package_name";
|
||||
const char* g_proc_func_name = "unknown_func_name";
|
||||
bool g_in_focus = false;
|
||||
|
||||
#define CHECK_FOCUS(func_name) \
|
||||
proc_func_name = func_name; \
|
||||
in_focus = check_focus(); \
|
||||
if (!in_focus) { \
|
||||
return NULL; \
|
||||
#define CHECK_FOCUS(func_name) \
|
||||
g_proc_func_name = func_name; \
|
||||
g_in_focus = check_focus(); \
|
||||
if (!g_in_focus) { \
|
||||
return NULL; \
|
||||
}
|
||||
|
||||
bool //
|
||||
check_focus() {
|
||||
const char* p = flags.focus;
|
||||
const char* p = g_flags.focus;
|
||||
if (!p || !*p) {
|
||||
return true;
|
||||
}
|
||||
size_t n = strlen(proc_func_name);
|
||||
size_t n = strlen(g_proc_func_name);
|
||||
|
||||
// On each iteration of the loop, set p and q so that p (inclusive) and q
|
||||
// (exclusive) bracket the interesting fragment of the comma-separated
|
||||
@@ -246,18 +247,18 @@ check_focus() {
|
||||
p += 9;
|
||||
}
|
||||
|
||||
// See if proc_func_name (with or without a "test_" or "bench_" prefix)
|
||||
// See if g_proc_func_name (with or without a "test_" or "bench_" prefix)
|
||||
// starts with the [p, q) string.
|
||||
if ((n >= q - p) && !strncmp(proc_func_name, p, q - p)) {
|
||||
if ((n >= q - p) && !strncmp(g_proc_func_name, p, q - p)) {
|
||||
return true;
|
||||
}
|
||||
const char* unprefixed_proc_func_name = NULL;
|
||||
size_t unprefixed_n = 0;
|
||||
if ((n >= q - p) && !strncmp(proc_func_name, "test_", 5)) {
|
||||
unprefixed_proc_func_name = proc_func_name + 5;
|
||||
if ((n >= q - p) && !strncmp(g_proc_func_name, "test_", 5)) {
|
||||
unprefixed_proc_func_name = g_proc_func_name + 5;
|
||||
unprefixed_n = n - 5;
|
||||
} else if ((n >= q - p) && !strncmp(proc_func_name, "bench_", 6)) {
|
||||
unprefixed_proc_func_name = proc_func_name + 6;
|
||||
} else if ((n >= q - p) && !strncmp(g_proc_func_name, "bench_", 6)) {
|
||||
unprefixed_proc_func_name = g_proc_func_name + 6;
|
||||
unprefixed_n = n - 6;
|
||||
}
|
||||
if (unprefixed_proc_func_name && (unprefixed_n >= q - p) &&
|
||||
@@ -280,17 +281,17 @@ check_focus() {
|
||||
|
||||
// The order matters here. Clang also defines "__GNUC__".
|
||||
#if defined(__clang__)
|
||||
const char* cc = "clang" WUFFS_TESTLIB_QUOTE(__clang_major__);
|
||||
const char* cc_version = __clang_version__;
|
||||
const char* g_cc = "clang" WUFFS_TESTLIB_QUOTE(__clang_major__);
|
||||
const char* g_cc_version = __clang_version__;
|
||||
#elif defined(__GNUC__)
|
||||
const char* cc = "gcc" WUFFS_TESTLIB_QUOTE(__GNUC__);
|
||||
const char* cc_version = __VERSION__;
|
||||
const char* g_cc = "gcc" WUFFS_TESTLIB_QUOTE(__GNUC__);
|
||||
const char* g_cc_version = __VERSION__;
|
||||
#elif defined(_MSC_VER)
|
||||
const char* cc = "cl";
|
||||
const char* cc_version = "???";
|
||||
const char* g_cc = "cl";
|
||||
const char* g_cc_version = "???";
|
||||
#else
|
||||
const char* cc = "cc";
|
||||
const char* cc_version = "???";
|
||||
const char* g_cc = "cc";
|
||||
const char* g_cc_version = "???";
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
@@ -300,12 +301,12 @@ typedef struct {
|
||||
size_t src_offset1;
|
||||
} golden_test;
|
||||
|
||||
bool bench_warm_up;
|
||||
struct timeval bench_start_tv;
|
||||
bool g_bench_warm_up;
|
||||
struct timeval g_bench_start_tv;
|
||||
|
||||
void //
|
||||
bench_start() {
|
||||
gettimeofday(&bench_start_tv, NULL);
|
||||
gettimeofday(&g_bench_start_tv, NULL);
|
||||
}
|
||||
|
||||
void //
|
||||
@@ -313,28 +314,28 @@ bench_finish(uint64_t iters, uint64_t n_bytes) {
|
||||
struct timeval bench_finish_tv;
|
||||
gettimeofday(&bench_finish_tv, NULL);
|
||||
int64_t micros =
|
||||
(int64_t)(bench_finish_tv.tv_sec - bench_start_tv.tv_sec) * 1000000 +
|
||||
(int64_t)(bench_finish_tv.tv_usec - bench_start_tv.tv_usec);
|
||||
(int64_t)(bench_finish_tv.tv_sec - g_bench_start_tv.tv_sec) * 1000000 +
|
||||
(int64_t)(bench_finish_tv.tv_usec - g_bench_start_tv.tv_usec);
|
||||
uint64_t nanos = 1;
|
||||
if (micros > 0) {
|
||||
nanos = (uint64_t)(micros)*1000;
|
||||
}
|
||||
uint64_t kb_per_s = n_bytes * 1000000 / nanos;
|
||||
|
||||
const char* name = proc_func_name;
|
||||
const char* name = g_proc_func_name;
|
||||
if ((strlen(name) >= 6) && !strncmp(name, "bench_", 6)) {
|
||||
name += 6;
|
||||
}
|
||||
if (bench_warm_up) {
|
||||
if (g_bench_warm_up) {
|
||||
printf("# (warm up) %s/%s\t%8" PRIu64 ".%06" PRIu64 " seconds\n", //
|
||||
name, cc, nanos / 1000000000, (nanos % 1000000000) / 1000);
|
||||
name, g_cc, nanos / 1000000000, (nanos % 1000000000) / 1000);
|
||||
} else if (!n_bytes) {
|
||||
printf("Benchmark%s/%s\t%8" PRIu64 "\t%8" PRIu64 " ns/op\n", //
|
||||
name, cc, iters, nanos / iters);
|
||||
name, g_cc, iters, nanos / iters);
|
||||
} else {
|
||||
printf("Benchmark%s/%s\t%8" PRIu64 "\t%8" PRIu64
|
||||
" ns/op\t%8d.%03d MB/s\n", //
|
||||
name, cc, iters, nanos / iters, //
|
||||
" ns/op\t%8d.%03d MB/s\n", //
|
||||
name, g_cc, iters, nanos / iters, //
|
||||
(int)(kb_per_s / 1000), (int)(kb_per_s % 1000));
|
||||
}
|
||||
// Flush stdout so that "wuffs bench | tee etc" still prints its numbers as
|
||||
@@ -384,17 +385,18 @@ test_main(int argc, char** argv, proc* tests, proc* benches) {
|
||||
fprintf(stderr, "%s\n", status);
|
||||
return 1;
|
||||
}
|
||||
if (flags.remaining_argc > 0) {
|
||||
if (g_flags.remaining_argc > 0) {
|
||||
fprintf(stderr, "unexpected (non-flag) argument\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
int reps = 1;
|
||||
proc* procs = tests;
|
||||
if (flags.bench) {
|
||||
reps = flags.reps + 1; // +1 for the warm up run.
|
||||
if (g_flags.bench) {
|
||||
reps = g_flags.reps + 1; // +1 for the warm up run.
|
||||
procs = benches;
|
||||
printf("# %s\n# %s version %s\n#\n", proc_package_name, cc, cc_version);
|
||||
printf("# %s\n# %s version %s\n#\n", g_proc_package_name, g_cc,
|
||||
g_cc_version);
|
||||
printf(
|
||||
"# The output format, including the \"Benchmark\" prefixes, is "
|
||||
"compatible with the\n"
|
||||
@@ -405,33 +407,34 @@ test_main(int argc, char** argv, proc* tests, proc* benches) {
|
||||
|
||||
int i;
|
||||
for (i = 0; i < reps; i++) {
|
||||
bench_warm_up = i == 0;
|
||||
g_bench_warm_up = i == 0;
|
||||
proc* p;
|
||||
for (p = procs; *p; p++) {
|
||||
proc_func_name = "unknown_func_name";
|
||||
fail_msg[0] = 0;
|
||||
in_focus = false;
|
||||
g_proc_func_name = "unknown_func_name";
|
||||
g_fail_msg[0] = 0;
|
||||
g_in_focus = false;
|
||||
const char* status = (*p)();
|
||||
if (!in_focus) {
|
||||
if (!g_in_focus) {
|
||||
continue;
|
||||
}
|
||||
if (status) {
|
||||
printf("%-16s%-8sFAIL %s: %s\n", proc_package_name, cc, proc_func_name,
|
||||
status);
|
||||
printf("%-16s%-8sFAIL %s: %s\n", g_proc_package_name, g_cc,
|
||||
g_proc_func_name, status);
|
||||
return 1;
|
||||
}
|
||||
if (i == 0) {
|
||||
tests_run++;
|
||||
g_tests_run++;
|
||||
}
|
||||
}
|
||||
if (i != 0) {
|
||||
continue;
|
||||
}
|
||||
if (flags.bench) {
|
||||
if (g_flags.bench) {
|
||||
printf("# %d benchmarks, 1+%d reps per benchmark, iterscale=%d\n",
|
||||
tests_run, flags.reps, (int)(flags.iterscale));
|
||||
g_tests_run, g_flags.reps, (int)(g_flags.iterscale));
|
||||
} else {
|
||||
printf("%-16s%-8sPASS (%d tests)\n", proc_package_name, cc, tests_run);
|
||||
printf("%-16s%-8sPASS (%d tests)\n", g_proc_package_name, g_cc,
|
||||
g_tests_run);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
@@ -693,7 +696,7 @@ check_io_buffers_equal(const char* prefix,
|
||||
if (!have || !want) {
|
||||
RETURN_FAIL("%sio_buffers_equal: NULL argument", prefix);
|
||||
}
|
||||
char* msg = fail_msg;
|
||||
char* msg = g_fail_msg;
|
||||
size_t i;
|
||||
size_t n = have->meta.wi < want->meta.wi ? have->meta.wi : want->meta.wi;
|
||||
for (i = 0; i < n; i++) {
|
||||
@@ -713,7 +716,7 @@ check_io_buffers_equal(const char* prefix,
|
||||
msg = hex_dump(msg, have, i);
|
||||
INCR_FAIL(msg, "excerpts of have (above) versus want (below):\n");
|
||||
msg = hex_dump(msg, want, i);
|
||||
return fail_msg;
|
||||
return g_fail_msg;
|
||||
}
|
||||
|
||||
// throughput_counter is whether to count dst or src bytes, or neither, when
|
||||
@@ -748,13 +751,13 @@ proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
|
||||
}
|
||||
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
|
||||
.data = global_want_slice,
|
||||
.data = g_want_slice_u8,
|
||||
});
|
||||
|
||||
if (!gt->src_filename) {
|
||||
@@ -837,10 +840,10 @@ proc_token_decoder(const char* (*codec_func)(wuffs_base__token_buffer*,
|
||||
}
|
||||
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
wuffs_base__token_buffer have = ((wuffs_base__token_buffer){
|
||||
.data = global_have_token_slice,
|
||||
.data = g_have_slice_token,
|
||||
});
|
||||
|
||||
if (!gt->src_filename) {
|
||||
@@ -905,7 +908,7 @@ do_bench_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
|
||||
uint64_t rlimit,
|
||||
uint64_t iters_unscaled) {
|
||||
return proc_io_buffers(codec_func, wuffs_initialize_flags, tcounter, gt,
|
||||
wlimit, rlimit, iters_unscaled * flags.iterscale,
|
||||
wlimit, rlimit, iters_unscaled * g_flags.iterscale,
|
||||
true);
|
||||
}
|
||||
|
||||
@@ -922,7 +925,7 @@ do_bench_token_decoder(const char* (*codec_func)(wuffs_base__token_buffer*,
|
||||
uint64_t rlimit,
|
||||
uint64_t iters_unscaled) {
|
||||
return proc_token_decoder(codec_func, wuffs_initialize_flags, tcounter, gt,
|
||||
wlimit, rlimit, iters_unscaled * flags.iterscale,
|
||||
wlimit, rlimit, iters_unscaled * g_flags.iterscale,
|
||||
true);
|
||||
}
|
||||
|
||||
@@ -949,7 +952,7 @@ do_test__wuffs_base__hasher_u32(wuffs_base__hasher_u32* b,
|
||||
size_t src_wi,
|
||||
uint32_t want) {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file_fragment(&src, src_filename, src_ri, src_wi));
|
||||
uint32_t have = wuffs_base__hasher_u32__update_u32(
|
||||
@@ -970,7 +973,7 @@ do_test__wuffs_base__image_config_decoder(wuffs_base__image_decoder* b,
|
||||
size_t src_wi,
|
||||
uint64_t want_num_frames) {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file_fragment(&src, src_filename, src_ri, src_wi));
|
||||
|
||||
@@ -1008,7 +1011,7 @@ do_test__wuffs_base__image_decoder(
|
||||
|
||||
wuffs_base__image_config ic = ((wuffs_base__image_config){});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file_fragment(&src, src_filename, src_ri, src_wi));
|
||||
CHECK_STATUS("decode_image_config",
|
||||
@@ -1030,10 +1033,10 @@ do_test__wuffs_base__image_decoder(
|
||||
|
||||
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
|
||||
CHECK_STATUS("set_from_slice", wuffs_base__pixel_buffer__set_from_slice(
|
||||
&pb, &ic.pixcfg, global_pixel_slice));
|
||||
&pb, &ic.pixcfg, g_pixel_slice_u8));
|
||||
CHECK_STATUS("decode_frame", wuffs_base__image_decoder__decode_frame(
|
||||
b, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC,
|
||||
global_work_slice, NULL));
|
||||
g_work_slice_u8, NULL));
|
||||
|
||||
uint64_t n = wuffs_base__pixel_config__pixbuf_len(&ic.pixcfg);
|
||||
if (n < 4) {
|
||||
@@ -1042,7 +1045,7 @@ do_test__wuffs_base__image_decoder(
|
||||
RETURN_FAIL("pixbuf_len too large");
|
||||
} else {
|
||||
wuffs_base__color_u32_argb_premul have_final_pixel =
|
||||
wuffs_base__load_u32le__no_bounds_check(&global_pixel_array[n - 4]);
|
||||
wuffs_base__load_u32le__no_bounds_check(&g_pixel_array_u8[n - 4]);
|
||||
if (have_final_pixel != want_final_pixel) {
|
||||
RETURN_FAIL("final pixel: have 0x%08" PRIX32 ", want 0x%08" PRIX32,
|
||||
have_final_pixel, want_final_pixel);
|
||||
@@ -1081,14 +1084,14 @@ do_test__wuffs_base__io_transformer(wuffs_base__io_transformer* b,
|
||||
}
|
||||
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file_fragment(&src, src_filename, src_ri, src_wi));
|
||||
CHECK_STATUS("transform_io", wuffs_base__io_transformer__transform_io(
|
||||
b, &have, &src, global_work_slice));
|
||||
b, &have, &src, g_work_slice_u8));
|
||||
if (have.meta.wi != want_wi) {
|
||||
RETURN_FAIL("dst wi: have %zu, want %zu", have.meta.wi, want_wi);
|
||||
}
|
||||
@@ -1104,16 +1107,16 @@ const char* //
|
||||
do_test__wuffs_base__token_decoder(wuffs_base__token_decoder* b,
|
||||
golden_test* gt) {
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
|
||||
.data = global_want_slice,
|
||||
.data = g_want_slice_u8,
|
||||
});
|
||||
wuffs_base__token_buffer tok = ((wuffs_base__token_buffer){
|
||||
.data = global_have_token_slice,
|
||||
.data = g_have_slice_token,
|
||||
});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
|
||||
if (gt->src_filename) {
|
||||
@@ -1125,7 +1128,7 @@ do_test__wuffs_base__token_decoder(wuffs_base__token_decoder* b,
|
||||
}
|
||||
|
||||
CHECK_STATUS("decode_tokens", wuffs_base__token_decoder__decode_tokens(
|
||||
b, &tok, &src, global_work_slice));
|
||||
b, &tok, &src, g_work_slice_u8));
|
||||
|
||||
uint64_t pos = 0;
|
||||
while (tok.meta.ri < tok.meta.wi) {
|
||||
|
||||
Reference in new issue
Block a user