Rename PUFFS to WUFFS, part 7 of N

This commit is contained in:
Nigel Tao committed 2017-11-30 18:02:59 +11:00
1 parent eda3130628
commit 3c708dfe59
23 files changed
+1610 -1610

No files matched your search

+14 -14
View File
@@ -16,8 +16,8 @@
uint32_t global_mimiclib_flate_unused_u32;
const char* mimic_bench_adler32(puffs_base__buf1* dst,
puffs_base__buf1* src,
const char* mimic_bench_adler32(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
uint64_t wlimit,
uint64_t rlimit) {
// TODO: don't ignore wlimit and rlimit.
@@ -31,8 +31,8 @@ const char* mimic_bench_adler32(puffs_base__buf1* dst,
return NULL;
}
const char* mimic_bench_crc32(puffs_base__buf1* dst,
puffs_base__buf1* src,
const char* mimic_bench_crc32(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
uint64_t wlimit,
uint64_t rlimit) {
// TODO: don't ignore wlimit and rlimit.
@@ -47,13 +47,13 @@ const char* mimic_bench_crc32(puffs_base__buf1* dst,
}
unsigned int mimic_flate_read_func(void* ctx, unsigned char** buf) {
puffs_base__buf1* src = (puffs_base__buf1*)(ctx);
wuffs_base__buf1* src = (wuffs_base__buf1*)(ctx);
*buf = src->ptr + src->ri;
return src->wi - src->ri;
}
int mimic_flate_write_func(void* ctx, unsigned char* ptr, unsigned int len) {
puffs_base__buf1* dst = (puffs_base__buf1*)(ctx);
wuffs_base__buf1* dst = (wuffs_base__buf1*)(ctx);
size_t n = len;
if (n > dst->len - dst->wi) {
return 1;
@@ -63,8 +63,8 @@ int mimic_flate_write_func(void* ctx, unsigned char* ptr, unsigned int len) {
return 0;
}
const char* mimic_flate_decode(puffs_base__buf1* dst,
puffs_base__buf1* src,
const char* mimic_flate_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
uint64_t wlimit,
uint64_t rlimit) {
// TODO: don't ignore wlimit and rlimit.
@@ -104,8 +104,8 @@ cleanup0:;
return ret;
}
const char* mimic_gzip_zlib_decode(puffs_base__buf1* dst,
puffs_base__buf1* src,
const char* mimic_gzip_zlib_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
uint64_t wlimit,
uint64_t rlimit,
bool gzip_instead_of_zlib) {
@@ -162,15 +162,15 @@ cleanup0:;
return ret;
}
const char* mimic_gzip_decode(puffs_base__buf1* dst,
puffs_base__buf1* src,
const char* mimic_gzip_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
uint64_t wlimit,
uint64_t rlimit) {
return mimic_gzip_zlib_decode(dst, src, wlimit, rlimit, true);
}
const char* mimic_zlib_decode(puffs_base__buf1* dst,
puffs_base__buf1* src,
const char* mimic_zlib_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
uint64_t wlimit,
uint64_t rlimit) {
return mimic_gzip_zlib_decode(dst, src, wlimit, rlimit, false);
+3 -3
View File
@@ -15,7 +15,7 @@
#include "gif_lib.h"
int mimic_gif_read_func(GifFileType* f, GifByteType* ptr, int len) {
puffs_base__buf1* src = (puffs_base__buf1*)(f->UserData);
wuffs_base__buf1* src = (wuffs_base__buf1*)(f->UserData);
if (len < 0) {
return 0;
}
@@ -29,7 +29,7 @@ int mimic_gif_read_func(GifFileType* f, GifByteType* ptr, int len) {
return n;
}
const char* mimic_gif_decode(puffs_base__buf1* dst, puffs_base__buf1* src) {
const char* mimic_gif_decode(wuffs_base__buf1* dst, wuffs_base__buf1* src) {
const char* ret = NULL;
// http://giflib.sourceforge.net/gif_lib.html#compatibility says that "A few
@@ -54,7 +54,7 @@ const char* mimic_gif_decode(puffs_base__buf1* dst, puffs_base__buf1* src) {
goto cleanup1;
}
// TODO: have Puffs accept multi-frame (animated) GIFs.
// TODO: have Wuffs accept multi-frame (animated) GIFs.
if (f->ImageCount != 1) {
ret = "GIF image has more than one frame";
goto cleanup1;
+176 -176
View File
@@ -13,9 +13,9 @@
// limitations under the License.
/*
This test program is typically run indirectly, by the "puffs test" or "puffs
This test program is typically run indirectly, by the "wuffs test" or "wuffs
bench" commands. These commands take an optional "-mimic" flag to check that
Puffs' output mimics (i.e. exactly matches) other libraries' output, such as
Wuffs' output mimics (i.e. exactly matches) other libraries' output, such as
giflib for GIF, libpng for PNG, etc.
To manually run this test:
@@ -27,15 +27,15 @@ done
Each edition should print "PASS", amongst other information, and exit(0).
Add the "puffs mimic cflags" (everything after the colon below) to the C
Add the "wuffs mimic cflags" (everything after the colon below) to the C
compiler flags (after the .c file) to run the mimic tests.
To manually run the benchmarks, replace "-Wall -Werror" with "-O3" and replace
the first "./a.out" with "./a.out -bench". Combine these changes with the
"puffs mimic cflags" to run the mimic benchmarks.
"wuffs mimic cflags" to run the mimic benchmarks.
*/
// !! puffs mimic cflags: -DPUFFS_MIMIC -lz
// !! wuffs mimic cflags: -DWUFFS_MIMIC -lz
#include "../../../gen/c/std/flate.c"
#include "../testlib/testlib.c"
@@ -120,7 +120,7 @@ golden_test zlib_pi_gt = {
// ---------------- Checksum Tests
void test_puffs_adler32() {
void test_wuffs_adler32() {
CHECK_FOCUS(__func__);
struct {
@@ -159,15 +159,15 @@ void test_puffs_adler32() {
};
int i;
for (i = 0; i < PUFFS_TESTLIB_ARRAY_SIZE(test_cases); i++) {
puffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
for (i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); i++) {
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, test_cases[i].filename)) {
return;
}
puffs_flate__adler32 checksum;
puffs_flate__adler32__initialize(&checksum, PUFFS_VERSION, 0);
wuffs_flate__adler32 checksum;
wuffs_flate__adler32__initialize(&checksum, WUFFS_VERSION, 0);
uint32_t got =
puffs_flate__adler32__update(&checksum, ((puffs_base__slice_u8){
wuffs_flate__adler32__update(&checksum, ((wuffs_base__slice_u8){
.ptr = src.ptr + src.ri,
.len = src.wi - src.ri,
}));
@@ -181,127 +181,127 @@ void test_puffs_adler32() {
// ---------------- Flate Tests
const char* puffs_flate_decode(puffs_base__buf1* dst,
puffs_base__buf1* src,
const char* wuffs_flate_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
uint64_t wlimit,
uint64_t rlimit) {
puffs_flate__flate_decoder dec;
puffs_flate__flate_decoder__initialize(&dec, PUFFS_VERSION, 0);
wuffs_flate__flate_decoder dec;
wuffs_flate__flate_decoder__initialize(&dec, WUFFS_VERSION, 0);
uint64_t wlim = 0;
uint64_t rlim = 0;
while (true) {
puffs_base__writer1 dst_writer = {.buf = dst};
wuffs_base__writer1 dst_writer = {.buf = dst};
if (wlimit) {
wlim = wlimit;
dst_writer.private_impl.limit.ptr_to_len = &wlim;
}
puffs_base__reader1 src_reader = {.buf = src};
wuffs_base__reader1 src_reader = {.buf = src};
if (rlimit) {
rlim = rlimit;
src_reader.private_impl.limit.ptr_to_len = &rlim;
}
puffs_flate__status s =
puffs_flate__flate_decoder__decode(&dec, dst_writer, src_reader);
wuffs_flate__status s =
wuffs_flate__flate_decoder__decode(&dec, dst_writer, src_reader);
if (s == PUFFS_FLATE__STATUS_OK) {
if (s == WUFFS_FLATE__STATUS_OK) {
return NULL;
}
if ((wlimit && (s == PUFFS_FLATE__SUSPENSION_SHORT_WRITE)) ||
(rlimit && (s == PUFFS_FLATE__SUSPENSION_SHORT_READ))) {
if ((wlimit && (s == WUFFS_FLATE__SUSPENSION_SHORT_WRITE)) ||
(rlimit && (s == WUFFS_FLATE__SUSPENSION_SHORT_READ))) {
continue;
}
return puffs_flate__status__string(s);
return wuffs_flate__status__string(s);
}
}
const char* puffs_zlib_decode(puffs_base__buf1* dst,
puffs_base__buf1* src,
const char* wuffs_zlib_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
uint64_t wlimit,
uint64_t rlimit) {
puffs_flate__zlib_decoder dec;
puffs_flate__zlib_decoder__initialize(&dec, PUFFS_VERSION, 0);
wuffs_flate__zlib_decoder dec;
wuffs_flate__zlib_decoder__initialize(&dec, WUFFS_VERSION, 0);
uint64_t wlim = 0;
uint64_t rlim = 0;
while (true) {
puffs_base__writer1 dst_writer = {.buf = dst};
wuffs_base__writer1 dst_writer = {.buf = dst};
if (wlimit) {
wlim = wlimit;
dst_writer.private_impl.limit.ptr_to_len = &wlim;
}
puffs_base__reader1 src_reader = {.buf = src};
wuffs_base__reader1 src_reader = {.buf = src};
if (rlimit) {
rlim = rlimit;
src_reader.private_impl.limit.ptr_to_len = &rlim;
}
puffs_flate__status s =
puffs_flate__zlib_decoder__decode(&dec, dst_writer, src_reader);
wuffs_flate__status s =
wuffs_flate__zlib_decoder__decode(&dec, dst_writer, src_reader);
if (s == PUFFS_FLATE__STATUS_OK) {
if (s == WUFFS_FLATE__STATUS_OK) {
return NULL;
}
if ((wlimit && (s == PUFFS_FLATE__SUSPENSION_SHORT_WRITE)) ||
(rlimit && (s == PUFFS_FLATE__SUSPENSION_SHORT_READ))) {
if ((wlimit && (s == WUFFS_FLATE__SUSPENSION_SHORT_WRITE)) ||
(rlimit && (s == WUFFS_FLATE__SUSPENSION_SHORT_READ))) {
continue;
}
return puffs_flate__status__string(s);
return wuffs_flate__status__string(s);
}
}
void test_puffs_flate_decode_256_bytes() {
void test_wuffs_flate_decode_256_bytes() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(puffs_flate_decode, &flate_256_bytes_gt, 0, 0);
do_test_buf1_buf1(wuffs_flate_decode, &flate_256_bytes_gt, 0, 0);
}
void test_puffs_flate_decode_flate_backref_crosses_blocks() {
void test_wuffs_flate_decode_flate_backref_crosses_blocks() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(puffs_flate_decode, &flate_flate_backref_crosses_blocks_gt,
do_test_buf1_buf1(wuffs_flate_decode, &flate_flate_backref_crosses_blocks_gt,
0, 0);
}
void test_puffs_flate_decode_midsummer() {
void test_wuffs_flate_decode_midsummer() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(puffs_flate_decode, &flate_midsummer_gt, 0, 0);
do_test_buf1_buf1(wuffs_flate_decode, &flate_midsummer_gt, 0, 0);
}
void test_puffs_flate_decode_pi() {
void test_wuffs_flate_decode_pi() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(puffs_flate_decode, &flate_pi_gt, 0, 0);
do_test_buf1_buf1(wuffs_flate_decode, &flate_pi_gt, 0, 0);
}
void test_puffs_flate_decode_pi_many_big_reads() {
void test_wuffs_flate_decode_pi_many_big_reads() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(puffs_flate_decode, &flate_pi_gt, 0, 4096);
do_test_buf1_buf1(wuffs_flate_decode, &flate_pi_gt, 0, 4096);
}
void test_puffs_flate_decode_pi_many_medium_reads() {
void test_wuffs_flate_decode_pi_many_medium_reads() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(puffs_flate_decode, &flate_pi_gt, 0, 599);
do_test_buf1_buf1(wuffs_flate_decode, &flate_pi_gt, 0, 599);
}
void test_puffs_flate_decode_pi_many_small_writes_reads() {
void test_wuffs_flate_decode_pi_many_small_writes_reads() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(puffs_flate_decode, &flate_pi_gt, 59, 61);
do_test_buf1_buf1(wuffs_flate_decode, &flate_pi_gt, 59, 61);
}
void test_puffs_flate_decode_romeo() {
void test_wuffs_flate_decode_romeo() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(puffs_flate_decode, &flate_romeo_gt, 0, 0);
do_test_buf1_buf1(wuffs_flate_decode, &flate_romeo_gt, 0, 0);
}
void test_puffs_flate_decode_romeo_fixed() {
void test_wuffs_flate_decode_romeo_fixed() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(puffs_flate_decode, &flate_romeo_fixed_gt, 0, 0);
do_test_buf1_buf1(wuffs_flate_decode, &flate_romeo_fixed_gt, 0, 0);
}
void test_puffs_flate_decode_split_src() {
void test_wuffs_flate_decode_split_src() {
CHECK_FOCUS(__func__);
puffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
puffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
puffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
golden_test* gt = &flate_256_bytes_gt;
if (!read_file(&src, gt->src_filename)) {
@@ -311,9 +311,9 @@ void test_puffs_flate_decode_split_src() {
return;
}
puffs_flate__flate_decoder dec;
puffs_base__writer1 dst_writer = {.buf = &got};
puffs_base__reader1 src_reader = {.buf = &src};
wuffs_flate__flate_decoder dec;
wuffs_base__writer1 dst_writer = {.buf = &got};
wuffs_base__reader1 src_reader = {.buf = &src};
int i;
for (i = 1; i < 32; i++) {
@@ -324,31 +324,31 @@ void test_puffs_flate_decode_split_src() {
}
got.wi = 0;
puffs_flate__flate_decoder__initialize(&dec, PUFFS_VERSION, 0);
wuffs_flate__flate_decoder__initialize(&dec, WUFFS_VERSION, 0);
src.closed = false;
src.ri = gt->src_offset0;
src.wi = split;
puffs_flate__status s0 =
puffs_flate__flate_decoder__decode(&dec, dst_writer, src_reader);
wuffs_flate__status s0 =
wuffs_flate__flate_decoder__decode(&dec, dst_writer, src_reader);
src.closed = true;
src.ri = split;
src.wi = gt->src_offset1;
puffs_flate__status s1 =
puffs_flate__flate_decoder__decode(&dec, dst_writer, src_reader);
wuffs_flate__status s1 =
wuffs_flate__flate_decoder__decode(&dec, dst_writer, src_reader);
if (s0 != PUFFS_FLATE__SUSPENSION_SHORT_READ) {
if (s0 != WUFFS_FLATE__SUSPENSION_SHORT_READ) {
FAIL("i=%d: s0: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", i, s0,
puffs_flate__status__string(s0), PUFFS_FLATE__SUSPENSION_SHORT_READ,
puffs_flate__status__string(PUFFS_FLATE__SUSPENSION_SHORT_READ));
wuffs_flate__status__string(s0), WUFFS_FLATE__SUSPENSION_SHORT_READ,
wuffs_flate__status__string(WUFFS_FLATE__SUSPENSION_SHORT_READ));
return;
}
if (s1 != PUFFS_FLATE__STATUS_OK) {
if (s1 != WUFFS_FLATE__STATUS_OK) {
FAIL("i=%d: s1: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", i, s1,
puffs_flate__status__string(s1), PUFFS_FLATE__STATUS_OK,
puffs_flate__status__string(PUFFS_FLATE__STATUS_OK));
wuffs_flate__status__string(s1), WUFFS_FLATE__STATUS_OK,
wuffs_flate__status__string(WUFFS_FLATE__STATUS_OK));
return;
}
@@ -360,45 +360,45 @@ void test_puffs_flate_decode_split_src() {
}
}
bool do_test_puffs_flate_history(int i,
bool do_test_wuffs_flate_history(int i,
golden_test* gt,
puffs_base__buf1* src,
puffs_base__buf1* got,
puffs_flate__flate_decoder* dec,
wuffs_base__buf1* src,
wuffs_base__buf1* got,
wuffs_flate__flate_decoder* dec,
uint32_t starting_history_index,
uint64_t limit,
puffs_flate__status want_s) {
wuffs_flate__status want_s) {
src->ri = gt->src_offset0;
src->wi = gt->src_offset1;
got->ri = 0;
got->wi = 0;
puffs_flate__flate_decoder__initialize(dec, PUFFS_VERSION, 0);
puffs_base__writer1 dst_writer = {.buf = got};
puffs_base__reader1 src_reader = {.buf = src};
wuffs_flate__flate_decoder__initialize(dec, WUFFS_VERSION, 0);
wuffs_base__writer1 dst_writer = {.buf = got};
wuffs_base__reader1 src_reader = {.buf = src};
dec->private_impl.f_history_index = starting_history_index;
dst_writer.private_impl.limit.ptr_to_len = &limit;
puffs_flate__status got_s =
puffs_flate__flate_decoder__decode(dec, dst_writer, src_reader);
wuffs_flate__status got_s =
wuffs_flate__flate_decoder__decode(dec, dst_writer, src_reader);
if (got_s != want_s) {
FAIL("i=%d: starting_history_index=0x%04" PRIX32
": decode status: got %" PRIi32 " (%s), want %" PRIi32 " (%s)",
i, starting_history_index, got_s, puffs_flate__status__string(got_s),
want_s, puffs_flate__status__string(want_s));
i, starting_history_index, got_s, wuffs_flate__status__string(got_s),
want_s, wuffs_flate__status__string(want_s));
return false;
}
return true;
}
void test_puffs_flate_history_full() {
void test_wuffs_flate_history_full() {
CHECK_FOCUS(__func__);
puffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
puffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
puffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
golden_test* gt = &flate_pi_gt;
if (!read_file(&src, gt->src_filename)) {
@@ -411,11 +411,11 @@ void test_puffs_flate_history_full() {
const int full_history_size = 0x8000;
int i;
for (i = -2; i <= +2; i++) {
puffs_flate__flate_decoder dec;
if (!do_test_puffs_flate_history(
wuffs_flate__flate_decoder dec;
if (!do_test_wuffs_flate_history(
i, gt, &src, &got, &dec, 0, want.wi + i,
i >= 0 ? PUFFS_FLATE__STATUS_OK
: PUFFS_FLATE__SUSPENSION_SHORT_WRITE)) {
i >= 0 ? WUFFS_FLATE__STATUS_OK
: WUFFS_FLATE__SUSPENSION_SHORT_WRITE)) {
return;
}
@@ -429,7 +429,7 @@ void test_puffs_flate_history_full() {
continue;
}
puffs_base__buf1 history_got = {
wuffs_base__buf1 history_got = {
.ptr = dec.private_impl.f_history,
.len = full_history_size,
.wi = full_history_size,
@@ -438,7 +438,7 @@ void test_puffs_flate_history_full() {
FAIL("i=%d: want file is too short", i);
return;
}
puffs_base__buf1 history_want = {
wuffs_base__buf1 history_want = {
.ptr = global_want_buffer + want.wi - (full_history_size - i),
.len = full_history_size,
.wi = full_history_size,
@@ -449,11 +449,11 @@ void test_puffs_flate_history_full() {
}
}
void test_puffs_flate_history_partial() {
void test_wuffs_flate_history_partial() {
CHECK_FOCUS(__func__);
puffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
puffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
golden_test* gt = &flate_pi_gt;
if (!read_file(&src, gt->src_filename)) {
@@ -466,17 +466,17 @@ void test_puffs_flate_history_partial() {
};
int i;
for (i = 0; i < PUFFS_TESTLIB_ARRAY_SIZE(starting_history_indexes); i++) {
for (i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(starting_history_indexes); i++) {
uint32_t starting_history_index = starting_history_indexes[i];
// The flate_pi_gt golden test file decodes to the digits of pi.
const char* fragment = "3.14";
const uint32_t fragment_length = 4;
puffs_flate__flate_decoder dec;
if (!do_test_puffs_flate_history(i, gt, &src, &got, &dec,
wuffs_flate__flate_decoder dec;
if (!do_test_wuffs_flate_history(i, gt, &src, &got, &dec,
starting_history_index, fragment_length,
PUFFS_FLATE__SUSPENSION_SHORT_WRITE)) {
WUFFS_FLATE__SUSPENSION_SHORT_WRITE)) {
return;
}
@@ -508,7 +508,7 @@ void test_puffs_flate_history_partial() {
}
}
void test_puffs_flate_table_redirect() {
void test_wuffs_flate_table_redirect() {
CHECK_FOCUS(__func__);
// Call init_huff with a Huffman code that looks like:
@@ -554,8 +554,8 @@ void test_puffs_flate_table_redirect() {
// 1st is the key in the first level table (9 bits).
// 2nd is the key in the second level table (variable bits).
puffs_flate__flate_decoder dec;
puffs_flate__flate_decoder__initialize(&dec, PUFFS_VERSION, 0);
wuffs_flate__flate_decoder dec;
wuffs_flate__flate_decoder__initialize(&dec, WUFFS_VERSION, 0);
// The initializer should zero out dec's fields, but to be paranoid, we zero
// it out explicitly.
@@ -578,10 +578,10 @@ void test_puffs_flate_table_redirect() {
dec.private_impl.f_code_lengths[n++] = 13;
dec.private_impl.f_code_lengths[n++] = 13;
puffs_flate__status s =
puffs_flate__flate_decoder__init_huff(&dec, 0, 0, n, 257);
wuffs_flate__status s =
wuffs_flate__flate_decoder__init_huff(&dec, 0, 0, n, 257);
if (s) {
FAIL("%s", puffs_flate__status__string(s));
FAIL("%s", wuffs_flate__status__string(s));
return;
}
@@ -640,11 +640,11 @@ void test_puffs_flate_table_redirect() {
}
}
void test_puffs_zlib_checksum_mismatch() {
void test_wuffs_zlib_checksum_mismatch() {
CHECK_FOCUS(__func__);
puffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
puffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, zlib_midsummer_gt.src_filename)) {
return;
@@ -656,35 +656,35 @@ void test_puffs_zlib_checksum_mismatch() {
// Flip a bit in the zlib checksum, which comes at the end of the file.
src.ptr[src.wi - 1] ^= 1;
puffs_flate__zlib_decoder dec;
puffs_flate__zlib_decoder__initialize(&dec, PUFFS_VERSION, 0);
puffs_base__writer1 got_writer = {.buf = &got};
puffs_base__reader1 src_reader = {.buf = &src};
wuffs_flate__zlib_decoder dec;
wuffs_flate__zlib_decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_base__writer1 got_writer = {.buf = &got};
wuffs_base__reader1 src_reader = {.buf = &src};
puffs_flate__status status =
puffs_flate__zlib_decoder__decode(&dec, got_writer, src_reader);
if (status != PUFFS_FLATE__ERROR_CHECKSUM_MISMATCH) {
wuffs_flate__status status =
wuffs_flate__zlib_decoder__decode(&dec, got_writer, src_reader);
if (status != WUFFS_FLATE__ERROR_CHECKSUM_MISMATCH) {
FAIL("status: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", status,
puffs_flate__status__string(status),
PUFFS_FLATE__ERROR_CHECKSUM_MISMATCH,
puffs_flate__status__string(PUFFS_FLATE__ERROR_CHECKSUM_MISMATCH));
wuffs_flate__status__string(status),
WUFFS_FLATE__ERROR_CHECKSUM_MISMATCH,
wuffs_flate__status__string(WUFFS_FLATE__ERROR_CHECKSUM_MISMATCH));
return;
}
}
void test_puffs_zlib_decode_midsummer() {
void test_wuffs_zlib_decode_midsummer() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(puffs_zlib_decode, &zlib_midsummer_gt, 0, 0);
do_test_buf1_buf1(wuffs_zlib_decode, &zlib_midsummer_gt, 0, 0);
}
void test_puffs_zlib_decode_pi() {
void test_wuffs_zlib_decode_pi() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(puffs_zlib_decode, &zlib_pi_gt, 0, 0);
do_test_buf1_buf1(wuffs_zlib_decode, &zlib_pi_gt, 0, 0);
}
// ---------------- Mimic Tests
#ifdef PUFFS_MIMIC
#ifdef WUFFS_MIMIC
#include "../mimiclib/flate.c"
@@ -739,21 +739,21 @@ void test_mimic_zlib_decode_pi() {
do_test_buf1_buf1(mimic_zlib_decode, &zlib_pi_gt, 0, 0);
}
#endif // PUFFS_MIMIC
#endif // WUFFS_MIMIC
// ---------------- Checksum Benches
uint32_t global_puffs_flate_unused_u32;
uint32_t global_wuffs_flate_unused_u32;
const char* puffs_bench_adler32(puffs_base__buf1* dst,
puffs_base__buf1* src,
const char* wuffs_bench_adler32(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
uint64_t wlimit,
uint64_t rlimit) {
// TODO: don't ignore wlimit and rlimit.
puffs_flate__adler32 checksum;
puffs_flate__adler32__initialize(&checksum, PUFFS_VERSION, 0);
global_puffs_flate_unused_u32 =
puffs_flate__adler32__update(&checksum, ((puffs_base__slice_u8){
wuffs_flate__adler32 checksum;
wuffs_flate__adler32__initialize(&checksum, WUFFS_VERSION, 0);
global_wuffs_flate_unused_u32 =
wuffs_flate__adler32__update(&checksum, ((wuffs_base__slice_u8){
.ptr = src->ptr + src->ri,
.len = src->wi - src->ri,
}));
@@ -761,49 +761,49 @@ const char* puffs_bench_adler32(puffs_base__buf1* dst,
return NULL;
}
void bench_puffs_adler32_10k() {
void bench_wuffs_adler32_10k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(puffs_bench_adler32, tc_src, &checksum_midsummer_gt, 0, 0,
do_bench_buf1_buf1(wuffs_bench_adler32, tc_src, &checksum_midsummer_gt, 0, 0,
150000);
}
void bench_puffs_adler32_100k() {
void bench_wuffs_adler32_100k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(puffs_bench_adler32, tc_src, &checksum_pi_gt, 0, 0, 15000);
do_bench_buf1_buf1(wuffs_bench_adler32, tc_src, &checksum_pi_gt, 0, 0, 15000);
}
// ---------------- Flate Benches
void bench_puffs_flate_decode_1k() {
void bench_wuffs_flate_decode_1k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(puffs_flate_decode, tc_dst, &flate_romeo_gt, 0, 0, 200000);
do_bench_buf1_buf1(wuffs_flate_decode, tc_dst, &flate_romeo_gt, 0, 0, 200000);
}
void bench_puffs_flate_decode_10k() {
void bench_wuffs_flate_decode_10k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(puffs_flate_decode, tc_dst, &flate_midsummer_gt, 0, 0,
do_bench_buf1_buf1(wuffs_flate_decode, tc_dst, &flate_midsummer_gt, 0, 0,
30000);
}
void bench_puffs_flate_decode_100k() {
void bench_wuffs_flate_decode_100k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(puffs_flate_decode, tc_dst, &flate_pi_gt, 0, 0, 3000);
do_bench_buf1_buf1(wuffs_flate_decode, tc_dst, &flate_pi_gt, 0, 0, 3000);
}
void bench_puffs_zlib_decode_10k() {
void bench_wuffs_zlib_decode_10k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(puffs_zlib_decode, tc_dst, &zlib_midsummer_gt, 0, 0,
do_bench_buf1_buf1(wuffs_zlib_decode, tc_dst, &zlib_midsummer_gt, 0, 0,
30000);
}
void bench_puffs_zlib_decode_100k() {
void bench_wuffs_zlib_decode_100k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(puffs_zlib_decode, tc_dst, &zlib_pi_gt, 0, 0, 3000);
do_bench_buf1_buf1(wuffs_zlib_decode, tc_dst, &zlib_pi_gt, 0, 0, 3000);
}
// ---------------- Mimic Benches
#ifdef PUFFS_MIMIC
#ifdef WUFFS_MIMIC
void bench_mimic_adler32_10k() {
CHECK_FOCUS(__func__);
@@ -865,32 +865,32 @@ void bench_mimic_zlib_decode_100k() {
do_bench_buf1_buf1(mimic_zlib_decode, tc_dst, &zlib_pi_gt, 0, 0, 3000);
}
#endif // PUFFS_MIMIC
#endif // WUFFS_MIMIC
// ---------------- Manifest
// The empty comments forces clang-format to place one element per line.
proc tests[] = {
// Flate Tests
test_puffs_adler32, //
test_puffs_flate_decode_256_bytes, //
test_puffs_flate_decode_flate_backref_crosses_blocks, //
test_puffs_flate_decode_midsummer, //
test_puffs_flate_decode_pi, //
test_puffs_flate_decode_pi_many_big_reads, //
test_puffs_flate_decode_pi_many_medium_reads, //
test_puffs_flate_decode_pi_many_small_writes_reads, //
test_puffs_flate_decode_romeo, //
test_puffs_flate_decode_romeo_fixed, //
test_puffs_flate_decode_split_src, //
test_puffs_flate_history_full, //
test_puffs_flate_history_partial, //
test_puffs_flate_table_redirect, //
test_puffs_zlib_checksum_mismatch, //
test_puffs_zlib_decode_midsummer, //
test_puffs_zlib_decode_pi, //
test_wuffs_adler32, //
test_wuffs_flate_decode_256_bytes, //
test_wuffs_flate_decode_flate_backref_crosses_blocks, //
test_wuffs_flate_decode_midsummer, //
test_wuffs_flate_decode_pi, //
test_wuffs_flate_decode_pi_many_big_reads, //
test_wuffs_flate_decode_pi_many_medium_reads, //
test_wuffs_flate_decode_pi_many_small_writes_reads, //
test_wuffs_flate_decode_romeo, //
test_wuffs_flate_decode_romeo_fixed, //
test_wuffs_flate_decode_split_src, //
test_wuffs_flate_history_full, //
test_wuffs_flate_history_partial, //
test_wuffs_flate_table_redirect, //
test_wuffs_zlib_checksum_mismatch, //
test_wuffs_zlib_decode_midsummer, //
test_wuffs_zlib_decode_pi, //
#ifdef PUFFS_MIMIC
#ifdef WUFFS_MIMIC
// Mimic Tests
test_mimic_flate_decode_256_bytes, //
@@ -904,7 +904,7 @@ proc tests[] = {
test_mimic_zlib_decode_midsummer, //
test_mimic_zlib_decode_pi, //
#endif // PUFFS_MIMIC
#endif // WUFFS_MIMIC
NULL,
};
@@ -912,15 +912,15 @@ proc tests[] = {
// The empty comments forces clang-format to place one element per line.
proc benches[] = {
// Flate Benches
bench_puffs_adler32_10k, //
bench_puffs_adler32_100k, //
bench_puffs_flate_decode_1k, //
bench_puffs_flate_decode_10k, //
bench_puffs_flate_decode_100k, //
bench_puffs_zlib_decode_10k, //
bench_puffs_zlib_decode_100k, //
bench_wuffs_adler32_10k, //
bench_wuffs_adler32_100k, //
bench_wuffs_flate_decode_1k, //
bench_wuffs_flate_decode_10k, //
bench_wuffs_flate_decode_100k, //
bench_wuffs_zlib_decode_10k, //
bench_wuffs_zlib_decode_100k, //
#ifdef PUFFS_MIMIC
#ifdef WUFFS_MIMIC
// Mimic Benches
bench_mimic_adler32_10k, //
@@ -935,7 +935,7 @@ proc benches[] = {
bench_mimic_zlib_decode_10k, //
bench_mimic_zlib_decode_100k, //
#endif // PUFFS_MIMIC
#endif // WUFFS_MIMIC
NULL,
};
+187 -187
View File
@@ -13,9 +13,9 @@
// limitations under the License.
/*
This test program is typically run indirectly, by the "puffs test" or "puffs
This test program is typically run indirectly, by the "wuffs test" or "wuffs
bench" commands. These commands take an optional "-mimic" flag to check that
Puffs' output mimics (i.e. exactly matches) other libraries' output, such as
Wuffs' output mimics (i.e. exactly matches) other libraries' output, such as
giflib for GIF, libpng for PNG, etc.
To manually run this test:
@@ -27,15 +27,15 @@ done
Each edition should print "PASS", amongst other information, and exit(0).
Add the "puffs mimic cflags" (everything after the colon below) to the C
Add the "wuffs mimic cflags" (everything after the colon below) to the C
compiler flags (after the .c file) to run the mimic tests.
To manually run the benchmarks, replace "-Wall -Werror" with "-O3" and replace
the first "./a.out" with "./a.out -bench". Combine these changes with the
"puffs mimic cflags" to run the mimic benchmarks.
"wuffs mimic cflags" to run the mimic benchmarks.
*/
// !! puffs mimic cflags: -DPUFFS_MIMIC -lgif
// !! wuffs mimic cflags: -DWUFFS_MIMIC -lgif
#include "../../../gen/c/std/gif.c"
#include "../testlib/testlib.c"
@@ -44,70 +44,70 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
void test_basic_bad_argument_out_of_range() {
CHECK_FOCUS(__func__);
puffs_gif__lzw_decoder dec;
puffs_gif__lzw_decoder__initialize(&dec, PUFFS_VERSION, 0);
wuffs_gif__lzw_decoder dec;
wuffs_gif__lzw_decoder__initialize(&dec, WUFFS_VERSION, 0);
// Setting to 8 is in the [2..8] range.
puffs_gif__lzw_decoder__set_literal_width(&dec, 8);
if (dec.private_impl.status != PUFFS_GIF__STATUS_OK) {
wuffs_gif__lzw_decoder__set_literal_width(&dec, 8);
if (dec.private_impl.status != WUFFS_GIF__STATUS_OK) {
FAIL("status: got %d, want %d", dec.private_impl.status,
PUFFS_GIF__STATUS_OK);
WUFFS_GIF__STATUS_OK);
}
// Setting to 999 is out of range.
puffs_gif__lzw_decoder__set_literal_width(&dec, 999);
if (dec.private_impl.status != PUFFS_GIF__ERROR_BAD_ARGUMENT) {
wuffs_gif__lzw_decoder__set_literal_width(&dec, 999);
if (dec.private_impl.status != WUFFS_GIF__ERROR_BAD_ARGUMENT) {
FAIL("status: got %d, want %d", dec.private_impl.status,
PUFFS_GIF__ERROR_BAD_ARGUMENT);
WUFFS_GIF__ERROR_BAD_ARGUMENT);
}
// That error status code should be sticky.
puffs_gif__lzw_decoder__set_literal_width(&dec, 8);
if (dec.private_impl.status != PUFFS_GIF__ERROR_BAD_ARGUMENT) {
wuffs_gif__lzw_decoder__set_literal_width(&dec, 8);
if (dec.private_impl.status != WUFFS_GIF__ERROR_BAD_ARGUMENT) {
FAIL("status: got %d, want %d", dec.private_impl.status,
PUFFS_GIF__ERROR_BAD_ARGUMENT);
WUFFS_GIF__ERROR_BAD_ARGUMENT);
}
}
void test_basic_bad_receiver() {
CHECK_FOCUS(__func__);
puffs_base__writer1 dst = {0};
puffs_base__reader1 src = {0};
puffs_gif__status status = puffs_gif__lzw_decoder__decode(NULL, dst, src);
if (status != PUFFS_GIF__ERROR_BAD_RECEIVER) {
FAIL("status: got %d, want %d", status, PUFFS_GIF__ERROR_BAD_RECEIVER);
wuffs_base__writer1 dst = {0};
wuffs_base__reader1 src = {0};
wuffs_gif__status status = wuffs_gif__lzw_decoder__decode(NULL, dst, src);
if (status != WUFFS_GIF__ERROR_BAD_RECEIVER) {
FAIL("status: got %d, want %d", status, WUFFS_GIF__ERROR_BAD_RECEIVER);
}
}
void test_basic_initializer_not_called() {
CHECK_FOCUS(__func__);
puffs_gif__lzw_decoder dec = {{0}};
puffs_base__writer1 dst = {0};
puffs_base__reader1 src = {0};
puffs_gif__status status = puffs_gif__lzw_decoder__decode(&dec, dst, src);
if (status != PUFFS_GIF__ERROR_INITIALIZER_NOT_CALLED) {
wuffs_gif__lzw_decoder dec = {{0}};
wuffs_base__writer1 dst = {0};
wuffs_base__reader1 src = {0};
wuffs_gif__status status = wuffs_gif__lzw_decoder__decode(&dec, dst, src);
if (status != WUFFS_GIF__ERROR_INITIALIZER_NOT_CALLED) {
FAIL("status: got %d, want %d", status,
PUFFS_GIF__ERROR_INITIALIZER_NOT_CALLED);
WUFFS_GIF__ERROR_INITIALIZER_NOT_CALLED);
}
}
void test_basic_puffs_version_bad() {
void test_basic_wuffs_version_bad() {
CHECK_FOCUS(__func__);
puffs_gif__lzw_decoder dec;
puffs_gif__lzw_decoder__initialize(&dec, 0, 0); // 0 is not PUFFS_VERSION.
if (dec.private_impl.status != PUFFS_GIF__ERROR_BAD_PUFFS_VERSION) {
wuffs_gif__lzw_decoder dec;
wuffs_gif__lzw_decoder__initialize(&dec, 0, 0); // 0 is not WUFFS_VERSION.
if (dec.private_impl.status != WUFFS_GIF__ERROR_BAD_WUFFS_VERSION) {
FAIL("status: got %d, want %d", dec.private_impl.status,
PUFFS_GIF__ERROR_BAD_PUFFS_VERSION);
WUFFS_GIF__ERROR_BAD_WUFFS_VERSION);
return;
}
}
void test_basic_puffs_version_good() {
void test_basic_wuffs_version_good() {
CHECK_FOCUS(__func__);
puffs_gif__lzw_decoder dec;
puffs_gif__lzw_decoder__initialize(&dec, PUFFS_VERSION, 0);
if (dec.private_impl.magic != PUFFS_BASE__MAGIC) {
FAIL("magic: got %u, want %u", dec.private_impl.magic, PUFFS_BASE__MAGIC);
wuffs_gif__lzw_decoder dec;
wuffs_gif__lzw_decoder__initialize(&dec, WUFFS_VERSION, 0);
if (dec.private_impl.magic != WUFFS_BASE__MAGIC) {
FAIL("magic: got %u, want %u", dec.private_impl.magic, WUFFS_BASE__MAGIC);
return;
}
if (dec.private_impl.f_literal_width != 8) {
@@ -119,19 +119,19 @@ void test_basic_puffs_version_good() {
void test_basic_status_is_error() {
CHECK_FOCUS(__func__);
if (puffs_gif__status__is_error(PUFFS_GIF__STATUS_OK)) {
if (wuffs_gif__status__is_error(WUFFS_GIF__STATUS_OK)) {
FAIL("is_error(OK) returned true");
return;
}
if (!puffs_gif__status__is_error(PUFFS_GIF__ERROR_BAD_PUFFS_VERSION)) {
FAIL("is_error(BAD_PUFFS_VERSION) returned false");
if (!wuffs_gif__status__is_error(WUFFS_GIF__ERROR_BAD_WUFFS_VERSION)) {
FAIL("is_error(BAD_WUFFS_VERSION) returned false");
return;
}
if (puffs_gif__status__is_error(PUFFS_GIF__SUSPENSION_SHORT_WRITE)) {
if (wuffs_gif__status__is_error(WUFFS_GIF__SUSPENSION_SHORT_WRITE)) {
FAIL("is_error(SHORT_WRITE) returned true");
return;
}
if (!puffs_gif__status__is_error(PUFFS_GIF__ERROR_LZW_CODE_IS_OUT_OF_RANGE)) {
if (!wuffs_gif__status__is_error(WUFFS_GIF__ERROR_LZW_CODE_IS_OUT_OF_RANGE)) {
FAIL("is_error(LZW_CODE_IS_OUT_OF_RANGE) returned false");
return;
}
@@ -139,33 +139,33 @@ void test_basic_status_is_error() {
void test_basic_status_strings() {
CHECK_FOCUS(__func__);
const char* s0 = puffs_gif__status__string(PUFFS_GIF__STATUS_OK);
const char* s0 = wuffs_gif__status__string(WUFFS_GIF__STATUS_OK);
const char* t0 = "gif: ok";
if (strcmp(s0, t0)) {
FAIL("got \"%s\", want \"%s\"", s0, t0);
return;
}
const char* s1 =
puffs_gif__status__string(PUFFS_GIF__ERROR_BAD_PUFFS_VERSION);
const char* t1 = "gif: bad puffs version";
wuffs_gif__status__string(WUFFS_GIF__ERROR_BAD_WUFFS_VERSION);
const char* t1 = "gif: bad wuffs version";
if (strcmp(s1, t1)) {
FAIL("got \"%s\", want \"%s\"", s1, t1);
return;
}
const char* s2 = puffs_gif__status__string(PUFFS_GIF__SUSPENSION_SHORT_WRITE);
const char* s2 = wuffs_gif__status__string(WUFFS_GIF__SUSPENSION_SHORT_WRITE);
const char* t2 = "gif: short write";
if (strcmp(s2, t2)) {
FAIL("got \"%s\", want \"%s\"", s2, t2);
return;
}
const char* s3 =
puffs_gif__status__string(PUFFS_GIF__ERROR_LZW_CODE_IS_OUT_OF_RANGE);
wuffs_gif__status__string(WUFFS_GIF__ERROR_LZW_CODE_IS_OUT_OF_RANGE);
const char* t3 = "gif: LZW code is out of range";
if (strcmp(s3, t3)) {
FAIL("got \"%s\", want \"%s\"", s3, t3);
return;
}
const char* s4 = puffs_gif__status__string(-254);
const char* s4 = wuffs_gif__status__string(-254);
const char* t4 = "gif: unknown status";
if (strcmp(s4, t4)) {
FAIL("got \"%s\", want \"%s\"", s4, t4);
@@ -175,31 +175,31 @@ void test_basic_status_strings() {
void test_basic_sub_struct_initializer() {
CHECK_FOCUS(__func__);
puffs_gif__decoder dec;
puffs_gif__decoder__initialize(&dec, PUFFS_VERSION, 0);
if (dec.private_impl.magic != PUFFS_BASE__MAGIC) {
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
if (dec.private_impl.magic != WUFFS_BASE__MAGIC) {
FAIL("outer magic: got %u, want %u", dec.private_impl.magic,
PUFFS_BASE__MAGIC);
WUFFS_BASE__MAGIC);
return;
}
if (dec.private_impl.f_lzw.private_impl.magic != PUFFS_BASE__MAGIC) {
if (dec.private_impl.f_lzw.private_impl.magic != WUFFS_BASE__MAGIC) {
FAIL("inner magic: got %u, want %u",
dec.private_impl.f_lzw.private_impl.magic, PUFFS_BASE__MAGIC);
dec.private_impl.f_lzw.private_impl.magic, WUFFS_BASE__MAGIC);
return;
}
}
// ---------------- LZW Tests
bool do_test_puffs_gif_lzw_decode(const char* src_filename,
bool do_test_wuffs_gif_lzw_decode(const char* src_filename,
uint64_t src_size,
const char* want_filename,
uint64_t want_size,
uint64_t wlimit,
uint64_t rlimit) {
puffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
puffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
puffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, src_filename)) {
return false;
@@ -224,20 +224,20 @@ bool do_test_puffs_gif_lzw_decode(const char* src_filename,
return false;
}
puffs_gif__lzw_decoder dec;
puffs_gif__lzw_decoder__initialize(&dec, PUFFS_VERSION, 0);
puffs_gif__lzw_decoder__set_literal_width(&dec, literal_width);
wuffs_gif__lzw_decoder dec;
wuffs_gif__lzw_decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_gif__lzw_decoder__set_literal_width(&dec, literal_width);
int num_iters = 0;
uint64_t wlim = 0;
uint64_t rlim = 0;
while (true) {
num_iters++;
puffs_base__writer1 got_writer = {.buf = &got};
wuffs_base__writer1 got_writer = {.buf = &got};
if (wlimit) {
wlim = wlimit;
got_writer.private_impl.limit.ptr_to_len = &wlim;
}
puffs_base__reader1 src_reader = {.buf = &src};
wuffs_base__reader1 src_reader = {.buf = &src};
if (rlimit) {
rlim = rlimit;
src_reader.private_impl.limit.ptr_to_len = &rlim;
@@ -245,24 +245,24 @@ bool do_test_puffs_gif_lzw_decode(const char* src_filename,
size_t old_wi = got.wi;
size_t old_ri = src.ri;
puffs_gif__status status =
puffs_gif__lzw_decoder__decode(&dec, got_writer, src_reader);
if (status == PUFFS_GIF__STATUS_OK) {
wuffs_gif__status status =
wuffs_gif__lzw_decoder__decode(&dec, got_writer, src_reader);
if (status == WUFFS_GIF__STATUS_OK) {
if (src.ri != src.wi) {
FAIL("decode returned ok but src was not exhausted");
return false;
}
break;
}
if ((status != PUFFS_GIF__SUSPENSION_SHORT_READ) &&
(status != PUFFS_GIF__SUSPENSION_SHORT_WRITE)) {
if ((status != WUFFS_GIF__SUSPENSION_SHORT_READ) &&
(status != WUFFS_GIF__SUSPENSION_SHORT_WRITE)) {
FAIL("status: got %" PRIi32 " (%s), want %" PRIi32 " (%s) or %" PRIi32
" (%s)",
status, puffs_gif__status__string(status),
PUFFS_GIF__SUSPENSION_SHORT_READ,
puffs_gif__status__string(PUFFS_GIF__SUSPENSION_SHORT_READ),
PUFFS_GIF__SUSPENSION_SHORT_WRITE,
puffs_gif__status__string(PUFFS_GIF__SUSPENSION_SHORT_WRITE));
status, wuffs_gif__status__string(status),
WUFFS_GIF__SUSPENSION_SHORT_READ,
wuffs_gif__status__string(WUFFS_GIF__SUSPENSION_SHORT_READ),
WUFFS_GIF__SUSPENSION_SHORT_WRITE,
wuffs_gif__status__string(WUFFS_GIF__SUSPENSION_SHORT_WRITE));
return false;
}
@@ -295,47 +295,47 @@ bool do_test_puffs_gif_lzw_decode(const char* src_filename,
return buf1s_equal("", &got, &want);
}
void test_puffs_gif_lzw_decode_many_big_reads() {
void test_wuffs_gif_lzw_decode_many_big_reads() {
CHECK_FOCUS(__func__);
do_test_puffs_gif_lzw_decode("../../testdata/bricks-gray.indexes.giflzw",
do_test_wuffs_gif_lzw_decode("../../testdata/bricks-gray.indexes.giflzw",
14731, "../../testdata/bricks-gray.indexes",
19200, 0, 4096);
}
void test_puffs_gif_lzw_decode_many_small_writes_reads() {
void test_wuffs_gif_lzw_decode_many_small_writes_reads() {
CHECK_FOCUS(__func__);
do_test_puffs_gif_lzw_decode("../../testdata/bricks-gray.indexes.giflzw",
do_test_wuffs_gif_lzw_decode("../../testdata/bricks-gray.indexes.giflzw",
14731, "../../testdata/bricks-gray.indexes",
19200, 41, 43);
}
void test_puffs_gif_lzw_decode_bricks_dither() {
void test_wuffs_gif_lzw_decode_bricks_dither() {
CHECK_FOCUS(__func__);
do_test_puffs_gif_lzw_decode("../../testdata/bricks-dither.indexes.giflzw",
do_test_wuffs_gif_lzw_decode("../../testdata/bricks-dither.indexes.giflzw",
14923, "../../testdata/bricks-dither.indexes",
19200, 0, 0);
}
void test_puffs_gif_lzw_decode_bricks_nodither() {
void test_wuffs_gif_lzw_decode_bricks_nodither() {
CHECK_FOCUS(__func__);
do_test_puffs_gif_lzw_decode("../../testdata/bricks-nodither.indexes.giflzw",
do_test_wuffs_gif_lzw_decode("../../testdata/bricks-nodither.indexes.giflzw",
13382, "../../testdata/bricks-nodither.indexes",
19200, 0, 0);
}
void test_puffs_gif_lzw_decode_pi() {
void test_wuffs_gif_lzw_decode_pi() {
CHECK_FOCUS(__func__);
do_test_puffs_gif_lzw_decode("../../testdata/pi.txt.giflzw", 50550,
do_test_wuffs_gif_lzw_decode("../../testdata/pi.txt.giflzw", 50550,
"../../testdata/pi.txt", 100003, 0, 0);
}
// ---------------- LZW Benches
bool do_bench_puffs_gif_lzw_decode(const char* filename, uint64_t reps) {
puffs_base__buf1 dst = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
puffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
puffs_base__writer1 dst_writer = {.buf = &dst};
puffs_base__reader1 src_reader = {.buf = &src};
bool do_bench_wuffs_gif_lzw_decode(const char* filename, uint64_t reps) {
wuffs_base__buf1 dst = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__writer1 dst_writer = {.buf = &dst};
wuffs_base__reader1 src_reader = {.buf = &src};
if (!read_file(&src, filename)) {
return false;
@@ -356,12 +356,12 @@ bool do_bench_puffs_gif_lzw_decode(const char* filename, uint64_t reps) {
for (i = 0; i < reps; i++) {
dst.wi = 0;
src.ri = 1; // Skip the literal width.
puffs_gif__lzw_decoder dec;
puffs_gif__lzw_decoder__initialize(&dec, PUFFS_VERSION, 0);
puffs_gif__status s =
puffs_gif__lzw_decoder__decode(&dec, dst_writer, src_reader);
wuffs_gif__lzw_decoder dec;
wuffs_gif__lzw_decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_gif__status s =
wuffs_gif__lzw_decoder__decode(&dec, dst_writer, src_reader);
if (s) {
FAIL("decode: %" PRIi32 " (%s)", s, puffs_gif__status__string(s));
FAIL("decode: %" PRIi32 " (%s)", s, wuffs_gif__status__string(s));
return false;
}
n_bytes += dst.wi;
@@ -370,57 +370,57 @@ bool do_bench_puffs_gif_lzw_decode(const char* filename, uint64_t reps) {
return true;
}
void bench_puffs_gif_lzw_decode_20k() {
void bench_wuffs_gif_lzw_decode_20k() {
CHECK_FOCUS(__func__);
do_bench_puffs_gif_lzw_decode("../../testdata/bricks-gray.indexes.giflzw",
do_bench_wuffs_gif_lzw_decode("../../testdata/bricks-gray.indexes.giflzw",
5000);
}
void bench_puffs_gif_lzw_decode_100k() {
void bench_wuffs_gif_lzw_decode_100k() {
CHECK_FOCUS(__func__);
do_bench_puffs_gif_lzw_decode("../../testdata/pi.txt.giflzw", 1000);
do_bench_wuffs_gif_lzw_decode("../../testdata/pi.txt.giflzw", 1000);
}
// ---------------- GIF Tests
const char* puffs_gif_decode(puffs_base__buf1* dst, puffs_base__buf1* src) {
puffs_gif__decoder dec;
puffs_gif__decoder__initialize(&dec, PUFFS_VERSION, 0);
puffs_base__writer1 dst_writer = {.buf = dst};
puffs_base__reader1 src_reader = {.buf = src};
puffs_gif__status s =
puffs_gif__decoder__decode(&dec, dst_writer, src_reader);
const char* wuffs_gif_decode(wuffs_base__buf1* dst, wuffs_base__buf1* src) {
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_base__writer1 dst_writer = {.buf = dst};
wuffs_base__reader1 src_reader = {.buf = src};
wuffs_gif__status s =
wuffs_gif__decoder__decode(&dec, dst_writer, src_reader);
if (s) {
return puffs_gif__status__string(s);
return wuffs_gif__status__string(s);
}
return NULL;
}
bool do_test_puffs_gif_decode(const char* filename,
bool do_test_wuffs_gif_decode(const char* filename,
const char* palette_filename,
const char* indexes_filename,
uint64_t wlimit,
uint64_t rlimit) {
puffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
puffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, filename)) {
return false;
}
puffs_gif__decoder dec;
puffs_gif__decoder__initialize(&dec, PUFFS_VERSION, 0);
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
int num_iters = 0;
uint64_t wlim = 0;
uint64_t rlim = 0;
while (true) {
num_iters++;
puffs_base__writer1 got_writer = {.buf = &got};
wuffs_base__writer1 got_writer = {.buf = &got};
if (wlimit) {
wlim = wlimit;
got_writer.private_impl.limit.ptr_to_len = &wlim;
}
puffs_base__reader1 src_reader = {.buf = &src};
wuffs_base__reader1 src_reader = {.buf = &src};
if (rlimit) {
rlim = rlimit;
src_reader.private_impl.limit.ptr_to_len = &rlim;
@@ -428,24 +428,24 @@ bool do_test_puffs_gif_decode(const char* filename,
size_t old_wi = got.wi;
size_t old_ri = src.ri;
puffs_gif__status status =
puffs_gif__decoder__decode(&dec, got_writer, src_reader);
if (status == PUFFS_GIF__STATUS_OK) {
wuffs_gif__status status =
wuffs_gif__decoder__decode(&dec, got_writer, src_reader);
if (status == WUFFS_GIF__STATUS_OK) {
if (src.ri != src.wi) {
FAIL("decode returned ok but src was not exhausted");
return false;
}
break;
}
if ((status != PUFFS_GIF__SUSPENSION_SHORT_READ) &&
(status != PUFFS_GIF__SUSPENSION_SHORT_WRITE)) {
if ((status != WUFFS_GIF__SUSPENSION_SHORT_READ) &&
(status != WUFFS_GIF__SUSPENSION_SHORT_WRITE)) {
FAIL("status: got %" PRIi32 " (%s), want %" PRIi32 " (%s) or %" PRIi32
" (%s)",
status, puffs_gif__status__string(status),
PUFFS_GIF__SUSPENSION_SHORT_READ,
puffs_gif__status__string(PUFFS_GIF__SUSPENSION_SHORT_READ),
PUFFS_GIF__SUSPENSION_SHORT_WRITE,
puffs_gif__status__string(PUFFS_GIF__SUSPENSION_SHORT_WRITE));
status, wuffs_gif__status__string(status),
WUFFS_GIF__SUSPENSION_SHORT_READ,
wuffs_gif__status__string(WUFFS_GIF__SUSPENSION_SHORT_READ),
WUFFS_GIF__SUSPENSION_SHORT_WRITE,
wuffs_gif__status__string(WUFFS_GIF__SUSPENSION_SHORT_WRITE));
return false;
}
@@ -486,8 +486,8 @@ bool do_test_puffs_gif_decode(const char* filename,
}
// TODO: provide a public API for getting the palette.
puffs_base__buf1 pal_got = {.ptr = dec.private_impl.f_gct, .len = 3 * 256};
puffs_base__buf1 pal_want = {.ptr = global_palette_buffer, .len = 3 * 256};
wuffs_base__buf1 pal_got = {.ptr = dec.private_impl.f_gct, .len = 3 * 256};
wuffs_base__buf1 pal_want = {.ptr = global_palette_buffer, .len = 3 * 256};
pal_got.wi = 3 * 256;
if (!read_file(&pal_want, palette_filename)) {
return false;
@@ -496,90 +496,90 @@ bool do_test_puffs_gif_decode(const char* filename,
return false;
}
puffs_base__buf1 ind_want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 ind_want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
if (!read_file(&ind_want, indexes_filename)) {
return false;
}
return buf1s_equal("indexes ", &got, &ind_want);
}
void test_puffs_gif_decode_input_is_a_gif() {
void test_wuffs_gif_decode_input_is_a_gif() {
CHECK_FOCUS(__func__);
do_test_puffs_gif_decode("../../testdata/bricks-dither.gif",
do_test_wuffs_gif_decode("../../testdata/bricks-dither.gif",
"../../testdata/bricks-dither.palette",
"../../testdata/bricks-dither.indexes", 0, 0);
}
void test_puffs_gif_decode_input_is_a_gif_many_big_reads() {
void test_wuffs_gif_decode_input_is_a_gif_many_big_reads() {
CHECK_FOCUS(__func__);
do_test_puffs_gif_decode("../../testdata/bricks-dither.gif",
do_test_wuffs_gif_decode("../../testdata/bricks-dither.gif",
"../../testdata/bricks-dither.palette",
"../../testdata/bricks-dither.indexes", 0, 4096);
}
void test_puffs_gif_decode_input_is_a_gif_many_medium_reads() {
void test_wuffs_gif_decode_input_is_a_gif_many_medium_reads() {
CHECK_FOCUS(__func__);
do_test_puffs_gif_decode("../../testdata/bricks-dither.gif",
do_test_wuffs_gif_decode("../../testdata/bricks-dither.gif",
"../../testdata/bricks-dither.palette",
"../../testdata/bricks-dither.indexes", 0,
787); // 787 tickles being in the middle of a
// decode_extension skip32 call.
}
void test_puffs_gif_decode_input_is_a_gif_many_small_writes_reads() {
void test_wuffs_gif_decode_input_is_a_gif_many_small_writes_reads() {
CHECK_FOCUS(__func__);
do_test_puffs_gif_decode("../../testdata/bricks-dither.gif",
do_test_wuffs_gif_decode("../../testdata/bricks-dither.gif",
"../../testdata/bricks-dither.palette",
"../../testdata/bricks-dither.indexes", 11, 13);
}
void test_puffs_gif_decode_input_is_a_png() {
void test_wuffs_gif_decode_input_is_a_png() {
CHECK_FOCUS(__func__);
puffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
puffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, "../../testdata/bricks-dither.png")) {
return;
}
puffs_gif__decoder dec;
puffs_gif__decoder__initialize(&dec, PUFFS_VERSION, 0);
puffs_base__writer1 got_writer = {.buf = &got};
puffs_base__reader1 src_reader = {.buf = &src};
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_base__writer1 got_writer = {.buf = &got};
wuffs_base__reader1 src_reader = {.buf = &src};
puffs_gif__status status =
puffs_gif__decoder__decode(&dec, got_writer, src_reader);
if (status != PUFFS_GIF__ERROR_BAD_GIF_HEADER) {
wuffs_gif__status status =
wuffs_gif__decoder__decode(&dec, got_writer, src_reader);
if (status != WUFFS_GIF__ERROR_BAD_GIF_HEADER) {
FAIL("status: got %" PRIi32 " (%s), want %" PRIi32 " (%s)", status,
puffs_gif__status__string(status), PUFFS_GIF__ERROR_BAD_GIF_HEADER,
puffs_gif__status__string(PUFFS_GIF__ERROR_BAD_GIF_HEADER));
wuffs_gif__status__string(status), WUFFS_GIF__ERROR_BAD_GIF_HEADER,
wuffs_gif__status__string(WUFFS_GIF__ERROR_BAD_GIF_HEADER));
return;
}
}
// ---------------- Mimic Tests
#ifdef PUFFS_MIMIC
#ifdef WUFFS_MIMIC
#include "../mimiclib/gif.c"
bool do_test_mimic_gif_decode(const char* filename) {
puffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, filename)) {
return false;
}
src.ri = 0;
puffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
const char* got_msg = puffs_gif_decode(&got, &src);
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
const char* got_msg = wuffs_gif_decode(&got, &src);
if (got_msg) {
FAIL("%s", got_msg);
return false;
}
src.ri = 0;
puffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
const char* want_msg = mimic_gif_decode(&want, &src);
if (want_msg) {
FAIL("%s", want_msg);
@@ -630,16 +630,16 @@ void test_mimic_gif_decode_pjw_thumbnail() {
do_test_mimic_gif_decode("../../testdata/pjw-thumbnail.gif");
}
#endif // PUFFS_MIMIC
#endif // WUFFS_MIMIC
// ---------------- GIF Benches
bool do_bench_gif_decode(const char* (*decode_func)(puffs_base__buf1*,
puffs_base__buf1*),
bool do_bench_gif_decode(const char* (*decode_func)(wuffs_base__buf1*,
wuffs_base__buf1*),
const char* filename,
uint64_t reps) {
puffs_base__buf1 dst = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
puffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 dst = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, filename)) {
return false;
@@ -662,30 +662,30 @@ bool do_bench_gif_decode(const char* (*decode_func)(puffs_base__buf1*,
return true;
}
void bench_puffs_gif_decode_1k() {
void bench_wuffs_gif_decode_1k() {
CHECK_FOCUS(__func__);
do_bench_gif_decode(puffs_gif_decode, "../../testdata/pjw-thumbnail.gif",
do_bench_gif_decode(wuffs_gif_decode, "../../testdata/pjw-thumbnail.gif",
200000);
}
void bench_puffs_gif_decode_10k() {
void bench_wuffs_gif_decode_10k() {
CHECK_FOCUS(__func__);
do_bench_gif_decode(puffs_gif_decode, "../../testdata/hat.gif", 10000);
do_bench_gif_decode(wuffs_gif_decode, "../../testdata/hat.gif", 10000);
}
void bench_puffs_gif_decode_100k() {
void bench_wuffs_gif_decode_100k() {
CHECK_FOCUS(__func__);
do_bench_gif_decode(puffs_gif_decode, "../../testdata/hibiscus.gif", 1000);
do_bench_gif_decode(wuffs_gif_decode, "../../testdata/hibiscus.gif", 1000);
}
void bench_puffs_gif_decode_1000k() {
void bench_wuffs_gif_decode_1000k() {
CHECK_FOCUS(__func__);
do_bench_gif_decode(puffs_gif_decode, "../../testdata/harvesters.gif", 100);
do_bench_gif_decode(wuffs_gif_decode, "../../testdata/harvesters.gif", 100);
}
// ---------------- Mimic Benches
#ifdef PUFFS_MIMIC
#ifdef WUFFS_MIMIC
void bench_mimic_gif_decode_1k() {
CHECK_FOCUS(__func__);
@@ -708,7 +708,7 @@ void bench_mimic_gif_decode_1000k() {
do_bench_gif_decode(mimic_gif_decode, "../../testdata/harvesters.gif", 100);
}
#endif // PUFFS_MIMIC
#endif // WUFFS_MIMIC
// ---------------- Manifest
@@ -718,27 +718,27 @@ proc tests[] = {
test_basic_bad_argument_out_of_range, //
test_basic_bad_receiver, //
test_basic_initializer_not_called, //
test_basic_puffs_version_bad, //
test_basic_puffs_version_good, //
test_basic_wuffs_version_bad, //
test_basic_wuffs_version_good, //
test_basic_status_is_error, //
test_basic_status_strings, //
test_basic_sub_struct_initializer, //
// LZW Tests
test_puffs_gif_lzw_decode_many_big_reads, //
test_puffs_gif_lzw_decode_many_small_writes_reads, //
test_puffs_gif_lzw_decode_bricks_dither, //
test_puffs_gif_lzw_decode_bricks_nodither, //
test_puffs_gif_lzw_decode_pi, //
test_wuffs_gif_lzw_decode_many_big_reads, //
test_wuffs_gif_lzw_decode_many_small_writes_reads, //
test_wuffs_gif_lzw_decode_bricks_dither, //
test_wuffs_gif_lzw_decode_bricks_nodither, //
test_wuffs_gif_lzw_decode_pi, //
// GIF Tests
test_puffs_gif_decode_input_is_a_gif, //
test_puffs_gif_decode_input_is_a_gif_many_big_reads, //
test_puffs_gif_decode_input_is_a_gif_many_medium_reads, //
test_puffs_gif_decode_input_is_a_gif_many_small_writes_reads, //
test_puffs_gif_decode_input_is_a_png, //
test_wuffs_gif_decode_input_is_a_gif, //
test_wuffs_gif_decode_input_is_a_gif_many_big_reads, //
test_wuffs_gif_decode_input_is_a_gif_many_medium_reads, //
test_wuffs_gif_decode_input_is_a_gif_many_small_writes_reads, //
test_wuffs_gif_decode_input_is_a_png, //
#ifdef PUFFS_MIMIC
#ifdef WUFFS_MIMIC
// Mimic Tests
test_mimic_gif_decode_bricks_dither, //
@@ -749,7 +749,7 @@ proc tests[] = {
test_mimic_gif_decode_hibiscus, //
test_mimic_gif_decode_pjw_thumbnail, //
#endif // PUFFS_MIMIC
#endif // WUFFS_MIMIC
NULL,
};
@@ -757,16 +757,16 @@ proc tests[] = {
// The empty comments forces clang-format to place one element per line.
proc benches[] = {
// LZW Benches
bench_puffs_gif_lzw_decode_20k, //
bench_puffs_gif_lzw_decode_100k, //
bench_wuffs_gif_lzw_decode_20k, //
bench_wuffs_gif_lzw_decode_100k, //
// GIF Benches
bench_puffs_gif_decode_1k, //
bench_puffs_gif_decode_10k, //
bench_puffs_gif_decode_100k, //
bench_puffs_gif_decode_1000k, //
bench_wuffs_gif_decode_1k, //
bench_wuffs_gif_decode_10k, //
bench_wuffs_gif_decode_100k, //
bench_wuffs_gif_decode_1000k, //
#ifdef PUFFS_MIMIC
#ifdef WUFFS_MIMIC
// Mimic Benches
bench_mimic_gif_decode_1k, //
@@ -774,7 +774,7 @@ proc benches[] = {
bench_mimic_gif_decode_100k, //
bench_mimic_gif_decode_1000k, //
#endif // PUFFS_MIMIC
#endif // WUFFS_MIMIC
NULL,
};
+21 -21
View File
@@ -22,7 +22,7 @@
#define BUFFER_SIZE (64 * 1024 * 1024)
#define PALETTE_BUFFER_SIZE (4 * 245)
#define PUFFS_TESTLIB_ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
#define WUFFS_TESTLIB_ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
uint8_t global_got_buffer[BUFFER_SIZE];
uint8_t global_want_buffer[BUFFER_SIZE];
@@ -82,10 +82,10 @@ bool check_focus() {
// copy/paste a string with a trailing comma.
} else {
// Strip a leading "Benchmark", if present, from the [p, q) string.
// Idiomatic C function names look like "test_puffs_gif_lzw_decode_pi"
// Idiomatic C function names look like "test_wuffs_gif_lzw_decode_pi"
// and won't start with "Benchmark". Stripping lets us conveniently
// copy/paste a string like "Benchmarkpuffs_gif_decode_10k/gcc" from the
// "puffs bench std/gif" output.
// copy/paste a string like "Benchmarkwuffs_gif_decode_10k/gcc" from the
// "wuffs bench std/gif" output.
if ((q - p >= 9) && !strncmp(p, "Benchmark", 9)) {
p += 9;
}
@@ -175,7 +175,7 @@ void bench_finish(uint64_t reps, uint64_t n_bytes) {
name, cc, reps, nanos / reps, //
(int)(kb_per_s / 1000), (int)(kb_per_s % 1000));
}
// Flush stdout so that "puffs bench | tee etc" still prints its numbers as
// Flush stdout so that "wuffs bench | tee etc" still prints its numbers as
// soon as they are available.
fflush(stdout);
}
@@ -264,10 +264,10 @@ int test_main(int argc, char** argv, proc* tests, proc* benches) {
return 0;
}
// PUFFS_BASE_HEADER_H is where puffs_base__buf1 is defined.
#ifdef PUFFS_BASE_HEADER_H
// WUFFS_BASE_HEADER_H is where wuffs_base__buf1 is defined.
#ifdef WUFFS_BASE_HEADER_H
bool read_file(puffs_base__buf1* dst, const char* path) {
bool read_file(wuffs_base__buf1* dst, const char* path) {
if (!dst || !path) {
FAIL("read_file: NULL argument");
return false;
@@ -322,7 +322,7 @@ bool read_file(puffs_base__buf1* dst, const char* path) {
return true;
}
char* hex_dump(char* msg, puffs_base__buf1* buf, size_t i) {
char* hex_dump(char* msg, wuffs_base__buf1* buf, size_t i) {
if (!msg || !buf) {
FAIL("hex_dump: NULL argument");
return NULL;
@@ -373,8 +373,8 @@ char* hex_dump(char* msg, puffs_base__buf1* buf, size_t i) {
}
bool buf1s_equal(const char* prefix,
puffs_base__buf1* got,
puffs_base__buf1* want) {
wuffs_base__buf1* got,
wuffs_base__buf1* want) {
if (!got || !want) {
FAIL("%sbuf1s_equal: NULL argument", prefix);
return false;
@@ -411,8 +411,8 @@ typedef enum {
tc_src = 2,
} throughput_counter;
bool proc_buf1_buf1(const char* (*codec_func)(puffs_base__buf1*,
puffs_base__buf1*,
bool proc_buf1_buf1(const char* (*codec_func)(wuffs_base__buf1*,
wuffs_base__buf1*,
uint64_t,
uint64_t),
throughput_counter tc,
@@ -430,9 +430,9 @@ bool proc_buf1_buf1(const char* (*codec_func)(puffs_base__buf1*,
return false;
}
puffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
puffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
puffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
if (!gt->src_filename) {
src.closed = true;
@@ -492,8 +492,8 @@ bool proc_buf1_buf1(const char* (*codec_func)(puffs_base__buf1*,
return true;
}
bool do_bench_buf1_buf1(const char* (*codec_func)(puffs_base__buf1*,
puffs_base__buf1*,
bool do_bench_buf1_buf1(const char* (*codec_func)(wuffs_base__buf1*,
wuffs_base__buf1*,
uint64_t,
uint64_t),
throughput_counter tc,
@@ -504,8 +504,8 @@ bool do_bench_buf1_buf1(const char* (*codec_func)(puffs_base__buf1*,
return proc_buf1_buf1(codec_func, tc, gt, wlimit, rlimit, reps, true);
}
bool do_test_buf1_buf1(const char* (*codec_func)(puffs_base__buf1*,
puffs_base__buf1*,
bool do_test_buf1_buf1(const char* (*codec_func)(wuffs_base__buf1*,
wuffs_base__buf1*,
uint64_t,
uint64_t),
golden_test* gt,
@@ -514,4 +514,4 @@ bool do_test_buf1_buf1(const char* (*codec_func)(puffs_base__buf1*,
return proc_buf1_buf1(codec_func, tc_neither, gt, wlimit, rlimit, 1, false);
}
#endif // PUFFS_BASE_HEADER_H
#endif // WUFFS_BASE_HEADER_H