mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 16:32:11 +01:00
Rename PUFFS to WUFFS, part 7 of N
This commit is contained in:
1 parent
eda3130628
commit
3c708dfe59
23 files changed
+1610
-1610
No files matched your search
+14
-14
@@ -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);
|
||||
|
||||
@@ -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
@@ -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
@@ -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
@@ -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
|
||||
Reference in new issue
Block a user