Have check_wuffs_version take the sizeof receiver

Also rename foo__initialize to foo__check_wuffs_version.
This commit is contained in:
Nigel Tao committed 2018-05-29 14:20:27 +10:00
1 parent d59eec7936
commit 87ab36f8c4
28 files changed
+354 -361

No files matched your search

+12 -8
View File
@@ -98,17 +98,19 @@ void test_wuffs_adler32_golden() {
int i;
for (i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); i++) {
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
if (!read_file(&src, test_cases[i].filename)) {
return;
}
int j;
for (j = 0; j < 2; j++) {
wuffs_adler32__hasher checksum;
wuffs_adler32__hasher__initialize(&checksum, WUFFS_VERSION, 0);
wuffs_adler32__hasher checksum = ((wuffs_adler32__hasher){});
wuffs_adler32__hasher__check_wuffs_version(&checksum, WUFFS_VERSION,
sizeof checksum);
uint32_t got;
uint32_t got = 0;
size_t num_fragments = 0;
size_t num_bytes = 0;
do {
@@ -164,8 +166,9 @@ void test_wuffs_adler32_pi() {
int i;
for (i = 0; i < 64; i++) {
wuffs_adler32__hasher checksum;
wuffs_adler32__hasher__initialize(&checksum, WUFFS_VERSION, 0);
wuffs_adler32__hasher checksum = ((wuffs_adler32__hasher){});
wuffs_adler32__hasher__check_wuffs_version(&checksum, WUFFS_VERSION,
sizeof checksum);
uint32_t got =
wuffs_adler32__hasher__update(&checksum, ((wuffs_base__slice_u8){
.ptr = (uint8_t*)(digits),
@@ -191,8 +194,9 @@ const char* wuffs_bench_adler32(wuffs_base__io_buffer* dst,
if (rlimit) {
len = wuffs_base__u64__min(len, rlimit);
}
wuffs_adler32__hasher checksum;
wuffs_adler32__hasher__initialize(&checksum, WUFFS_VERSION, 0);
wuffs_adler32__hasher checksum = ((wuffs_adler32__hasher){});
wuffs_adler32__hasher__check_wuffs_version(&checksum, WUFFS_VERSION,
sizeof checksum);
global_wuffs_adler32_unused_u32 =
wuffs_adler32__hasher__update(&checksum, ((wuffs_base__slice_u8){
.ptr = src->ptr + src->ri,
+12 -8
View File
@@ -98,17 +98,19 @@ void test_wuffs_crc32_ieee_golden() {
int i;
for (i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); i++) {
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
if (!read_file(&src, test_cases[i].filename)) {
return;
}
int j;
for (j = 0; j < 2; j++) {
wuffs_crc32__ieee_hasher checksum;
wuffs_crc32__ieee_hasher__initialize(&checksum, WUFFS_VERSION, 0);
wuffs_crc32__ieee_hasher checksum = ((wuffs_crc32__ieee_hasher){});
wuffs_crc32__ieee_hasher__check_wuffs_version(&checksum, WUFFS_VERSION,
sizeof checksum);
uint32_t got;
uint32_t got = 0;
size_t num_fragments = 0;
size_t num_bytes = 0;
do {
@@ -164,8 +166,9 @@ void test_wuffs_crc32_ieee_pi() {
int i;
for (i = 0; i < 64; i++) {
wuffs_crc32__ieee_hasher checksum;
wuffs_crc32__ieee_hasher__initialize(&checksum, WUFFS_VERSION, 0);
wuffs_crc32__ieee_hasher checksum = ((wuffs_crc32__ieee_hasher){});
wuffs_crc32__ieee_hasher__check_wuffs_version(&checksum, WUFFS_VERSION,
sizeof checksum);
uint32_t got = wuffs_crc32__ieee_hasher__update(
&checksum, ((wuffs_base__slice_u8){
.ptr = (uint8_t*)(digits),
@@ -191,8 +194,9 @@ const char* wuffs_bench_crc32_ieee(wuffs_base__io_buffer* dst,
if (rlimit) {
len = wuffs_base__u64__min(len, rlimit);
}
wuffs_crc32__ieee_hasher checksum;
wuffs_crc32__ieee_hasher__initialize(&checksum, WUFFS_VERSION, 0);
wuffs_crc32__ieee_hasher checksum = ((wuffs_crc32__ieee_hasher){});
wuffs_crc32__ieee_hasher__check_wuffs_version(&checksum, WUFFS_VERSION,
sizeof checksum);
global_wuffs_crc32_unused_u32 =
wuffs_crc32__ieee_hasher__update(&checksum, ((wuffs_base__slice_u8){
.ptr = src->ptr + src->ri,
+35 -25
View File
@@ -111,8 +111,8 @@ const char* wuffs_deflate_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
wuffs_deflate__decoder dec;
wuffs_deflate__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
wuffs_deflate__decoder__check_wuffs_version(&dec, WUFFS_VERSION, sizeof dec);
while (true) {
wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(dst);
if (wlimit) {
@@ -192,9 +192,12 @@ void test_wuffs_deflate_decode_romeo_fixed() {
void test_wuffs_deflate_decode_split_src() {
CHECK_FOCUS(__func__);
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer want =
((wuffs_base__io_buffer){.ptr = global_want_buffer, .len = BUFFER_SIZE});
golden_test* gt = &deflate_256_bytes_gt;
if (!read_file(&src, gt->src_filename)) {
@@ -204,7 +207,6 @@ void test_wuffs_deflate_decode_split_src() {
return;
}
wuffs_deflate__decoder dec;
wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(&got);
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
@@ -217,7 +219,9 @@ void test_wuffs_deflate_decode_split_src() {
}
got.wi = 0;
wuffs_deflate__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
wuffs_deflate__decoder__check_wuffs_version(&dec, WUFFS_VERSION,
sizeof dec);
src.closed = false;
src.ri = gt->src_offset0;
@@ -267,7 +271,6 @@ bool do_test_wuffs_deflate_history(int i,
got->ri = 0;
got->wi = 0;
wuffs_deflate__decoder__initialize(dec, WUFFS_VERSION, 0);
wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(got);
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(src);
@@ -290,9 +293,12 @@ bool do_test_wuffs_deflate_history(int i,
void test_wuffs_deflate_history_full() {
CHECK_FOCUS(__func__);
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer want =
((wuffs_base__io_buffer){.ptr = global_want_buffer, .len = BUFFER_SIZE});
golden_test* gt = &deflate_pi_gt;
if (!read_file(&src, gt->src_filename)) {
@@ -305,7 +311,10 @@ void test_wuffs_deflate_history_full() {
const int full_history_size = 0x8000;
int i;
for (i = -2; i <= +2; i++) {
wuffs_deflate__decoder dec;
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
wuffs_deflate__decoder__check_wuffs_version(&dec, WUFFS_VERSION,
sizeof dec);
if (!do_test_wuffs_deflate_history(
i, gt, &src, &got, &dec, 0, want.wi + i,
i >= 0 ? WUFFS_DEFLATE__STATUS_OK
@@ -323,20 +332,20 @@ void test_wuffs_deflate_history_full() {
continue;
}
wuffs_base__io_buffer history_got = {
wuffs_base__io_buffer history_got = ((wuffs_base__io_buffer){
.ptr = dec.private_impl.f_history,
.len = full_history_size,
.wi = full_history_size,
};
});
if (want.wi < full_history_size - i) {
FAIL("i=%d: want file is too short", i);
return;
}
wuffs_base__io_buffer history_want = {
wuffs_base__io_buffer history_want = ((wuffs_base__io_buffer){
.ptr = global_want_buffer + want.wi - (full_history_size - i),
.len = full_history_size,
.wi = full_history_size,
};
});
if (!io_buffers_equal("", &history_got, &history_want)) {
return;
}
@@ -346,8 +355,10 @@ void test_wuffs_deflate_history_full() {
void test_wuffs_deflate_history_partial() {
CHECK_FOCUS(__func__);
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
golden_test* gt = &deflate_pi_gt;
if (!read_file(&src, gt->src_filename)) {
@@ -367,7 +378,10 @@ void test_wuffs_deflate_history_partial() {
const char* fragment = "3.14";
const uint32_t fragment_length = 4;
wuffs_deflate__decoder dec;
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
wuffs_deflate__decoder__check_wuffs_version(&dec, WUFFS_VERSION,
sizeof dec);
if (!do_test_wuffs_deflate_history(i, gt, &src, &got, &dec,
starting_history_index, fragment_length,
WUFFS_DEFLATE__SUSPENSION_SHORT_WRITE)) {
@@ -448,12 +462,8 @@ void test_wuffs_deflate_table_redirect() {
// 1st is the key in the first level table (9 bits).
// 2nd is the key in the second level table (variable bits).
wuffs_deflate__decoder dec;
wuffs_deflate__decoder__initialize(&dec, WUFFS_VERSION, 0);
// The initializer should zero out dec's fields, but to be paranoid, we zero
// it out explicitly.
memset(&dec.private_impl.f_huffs[0], 0, sizeof(dec.private_impl.f_huffs[0]));
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
wuffs_deflate__decoder__check_wuffs_version(&dec, WUFFS_VERSION, sizeof dec);
int i;
int n = 0;
+64 -47
View File
@@ -50,8 +50,8 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
void test_basic_bad_receiver() {
CHECK_FOCUS(__func__);
wuffs_base__image_config ic = {{0}};
wuffs_base__io_reader src = {{0}};
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src = ((wuffs_base__io_reader){});
wuffs_gif__status status = wuffs_gif__decoder__decode_config(NULL, &ic, src);
if (status != WUFFS_GIF__ERROR_BAD_RECEIVER) {
FAIL("decode_config: got %d, want %d", status,
@@ -61,9 +61,9 @@ void test_basic_bad_receiver() {
void test_basic_initializer_not_called() {
CHECK_FOCUS(__func__);
wuffs_gif__decoder dec = {{0}};
wuffs_base__image_config ic = {{0}};
wuffs_base__io_reader src = {{0}};
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src = ((wuffs_base__io_reader){});
wuffs_gif__status status = wuffs_gif__decoder__decode_config(&dec, &ic, src);
if (status != WUFFS_GIF__ERROR_INITIALIZER_NOT_CALLED) {
FAIL("decode_config: got %d, want %d", status,
@@ -73,8 +73,9 @@ void test_basic_initializer_not_called() {
void test_basic_wuffs_version_bad() {
CHECK_FOCUS(__func__);
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, 0, 0); // 0 is not WUFFS_VERSION.
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_gif__decoder__check_wuffs_version(&dec, 0,
0); // 0 is not WUFFS_VERSION.
if (dec.private_impl.status != WUFFS_GIF__ERROR_BAD_WUFFS_VERSION) {
FAIL("decode_config: got %d, want %d", dec.private_impl.status,
WUFFS_GIF__ERROR_BAD_WUFFS_VERSION);
@@ -84,8 +85,8 @@ void test_basic_wuffs_version_bad() {
void test_basic_wuffs_version_good() {
CHECK_FOCUS(__func__);
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_gif__decoder__check_wuffs_version(&dec, WUFFS_VERSION, sizeof dec);
if (dec.private_impl.magic != WUFFS_BASE__MAGIC) {
FAIL("magic: got %u, want %u", dec.private_impl.magic, WUFFS_BASE__MAGIC);
return;
@@ -150,8 +151,8 @@ void test_basic_status_strings() {
void test_basic_sub_struct_initializer() {
CHECK_FOCUS(__func__);
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_gif__decoder__check_wuffs_version(&dec, WUFFS_VERSION, sizeof dec);
if (dec.private_impl.magic != WUFFS_BASE__MAGIC) {
FAIL("outer magic: got %u, want %u", dec.private_impl.magic,
WUFFS_BASE__MAGIC);
@@ -172,9 +173,12 @@ bool do_test_wuffs_lzw_decode(const char* src_filename,
uint64_t want_size,
uint64_t wlimit,
uint64_t rlimit) {
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer want =
((wuffs_base__io_buffer){.ptr = global_want_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
if (!read_file(&src, src_filename)) {
return false;
@@ -199,8 +203,8 @@ bool do_test_wuffs_lzw_decode(const char* src_filename,
return false;
}
wuffs_gif__lzw_decoder dec;
wuffs_gif__lzw_decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_gif__lzw_decoder dec = ((wuffs_gif__lzw_decoder){});
wuffs_gif__lzw_decoder__check_wuffs_version(&dec, WUFFS_VERSION, sizeof dec);
wuffs_gif__lzw_decoder__set_literal_width(&dec, literal_width);
int num_iters = 0;
while (true) {
@@ -299,8 +303,10 @@ void test_wuffs_lzw_decode_pi() {
// ---------------- LZW Benches
bool do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) {
wuffs_base__io_buffer dst = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer dst =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(&dst);
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
@@ -324,8 +330,9 @@ bool do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) {
for (i = 0; i < iters; i++) {
dst.wi = 0;
src.ri = 1; // Skip the literal width.
wuffs_gif__lzw_decoder dec;
wuffs_gif__lzw_decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_gif__lzw_decoder dec = ((wuffs_gif__lzw_decoder){});
wuffs_gif__lzw_decoder__check_wuffs_version(&dec, WUFFS_VERSION,
sizeof dec);
wuffs_gif__status s =
wuffs_gif__lzw_decoder__decode(&dec, dst_writer, src_reader);
if (s) {
@@ -352,10 +359,10 @@ void bench_wuffs_lzw_decode_100k() {
const char* wuffs_gif_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src) {
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_gif__decoder__check_wuffs_version(&dec, WUFFS_VERSION, sizeof dec);
wuffs_base__image_buffer ib = ((wuffs_base__image_buffer){});
wuffs_base__image_config ic = {{0}};
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(src);
wuffs_gif__status s =
wuffs_gif__decoder__decode_config(&dec, &ic, src_reader);
@@ -389,19 +396,21 @@ bool do_test_wuffs_gif_decode(const char* filename,
const char* palette_filename,
const char* indexes_filename,
uint64_t rlimit) {
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
if (!read_file(&src, filename)) {
return false;
}
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_gif__decoder__check_wuffs_version(&dec, WUFFS_VERSION, sizeof dec);
wuffs_base__image_buffer ib = ((wuffs_base__image_buffer){});
{
wuffs_base__image_config ic = {{0}};
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
wuffs_gif__status status =
wuffs_gif__decoder__decode_config(&dec, &ic, src_reader);
@@ -540,14 +549,15 @@ bool do_test_wuffs_gif_decode(const char* filename,
void test_wuffs_gif_call_sequence() {
CHECK_FOCUS(__func__);
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
if (!read_file(&src, "../../data/bricks-dither.gif")) {
return;
}
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_gif__decoder__check_wuffs_version(&dec, WUFFS_VERSION, sizeof dec);
wuffs_base__image_buffer ib = ((wuffs_base__image_buffer){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
@@ -574,11 +584,11 @@ bool do_test_wuffs_gif_decode_animated(
return false;
}
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_gif__decoder__check_wuffs_version(&dec, WUFFS_VERSION, sizeof dec);
wuffs_base__image_buffer ib = ((wuffs_base__image_buffer){});
wuffs_base__image_config ic = {{0}};
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
wuffs_gif__status status =
@@ -669,14 +679,15 @@ void test_wuffs_gif_decode_animated_small() {
void test_wuffs_gif_decode_frame_out_of_bounds() {
CHECK_FOCUS(__func__);
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
if (!read_file(&src, "../../data/artificial/gif-frame-out-of-bounds.gif")) {
return;
}
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_base__image_config ic = {{0}};
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_gif__decoder__check_wuffs_version(&dec, WUFFS_VERSION, sizeof dec);
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
wuffs_gif__status s =
wuffs_gif__decoder__decode_config(&dec, &ic, src_reader);
@@ -737,15 +748,16 @@ void test_wuffs_gif_decode_input_is_a_gif_many_small_reads() {
void test_wuffs_gif_decode_input_is_a_png() {
CHECK_FOCUS(__func__);
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
if (!read_file(&src, "../../data/bricks-dither.png")) {
return;
}
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_base__image_config ic = {{0}};
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
wuffs_gif__decoder__check_wuffs_version(&dec, WUFFS_VERSION, sizeof dec);
wuffs_base__image_config ic = ((wuffs_base__image_config){});
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
wuffs_gif__status status =
@@ -763,13 +775,15 @@ void test_wuffs_gif_decode_input_is_a_png() {
#ifdef WUFFS_MIMIC
bool do_test_mimic_gif_decode(const char* filename) {
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
if (!read_file(&src, filename)) {
return false;
}
src.ri = 0;
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
const char* got_msg = wuffs_gif_decode(&got, &src);
if (got_msg) {
FAIL("%s", got_msg);
@@ -777,7 +791,8 @@ bool do_test_mimic_gif_decode(const char* filename) {
}
src.ri = 0;
wuffs_base__io_buffer want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer want =
((wuffs_base__io_buffer){.ptr = global_want_buffer, .len = BUFFER_SIZE});
const char* want_msg = mimic_gif_decode(&want, &src);
if (want_msg) {
FAIL("%s", want_msg);
@@ -851,8 +866,10 @@ bool do_bench_gif_decode(const char* (*decode_func)(wuffs_base__io_buffer*,
wuffs_base__io_buffer*),
const char* filename,
uint64_t iters_unscaled) {
wuffs_base__io_buffer dst = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer dst =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
if (!read_file(&src, filename)) {
return false;
+8 -6
View File
@@ -66,8 +66,8 @@ const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
wuffs_gzip__decoder dec;
wuffs_gzip__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_gzip__decoder dec = ((wuffs_gzip__decoder){});
wuffs_gzip__decoder__check_wuffs_version(&dec, WUFFS_VERSION, sizeof dec);
while (true) {
wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(dst);
@@ -94,8 +94,10 @@ const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst,
}
bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) {
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
if (!read_file(&src, gzip_midsummer_gt.src_filename)) {
return false;
@@ -112,8 +114,8 @@ bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) {
int end_limit;
for (end_limit = 0; end_limit < 10; end_limit++) {
wuffs_gzip__decoder dec;
wuffs_gzip__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_gzip__decoder dec = ((wuffs_gzip__decoder){});
wuffs_gzip__decoder__check_wuffs_version(&dec, WUFFS_VERSION, sizeof dec);
wuffs_gzip__decoder__set_ignore_checksum(&dec, ignore_checksum);
got.wi = 0;
wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got);
+8 -6
View File
@@ -81,8 +81,8 @@ const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
wuffs_zlib__decoder dec;
wuffs_zlib__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_zlib__decoder dec = ((wuffs_zlib__decoder){});
wuffs_zlib__decoder__check_wuffs_version(&dec, WUFFS_VERSION, sizeof dec);
while (true) {
wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(dst);
@@ -109,8 +109,10 @@ const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst,
}
bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) {
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
if (!read_file(&src, zlib_midsummer_gt.src_filename)) {
return false;
@@ -126,8 +128,8 @@ bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) {
int end_limit;
for (end_limit = 0; end_limit < 10; end_limit++) {
wuffs_zlib__decoder dec;
wuffs_zlib__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_zlib__decoder dec = ((wuffs_zlib__decoder){});
wuffs_zlib__decoder__check_wuffs_version(&dec, WUFFS_VERSION, sizeof dec);
wuffs_zlib__decoder__set_ignore_checksum(&dec, ignore_checksum);
got.wi = 0;
wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got);
+6 -3
View File
@@ -520,9 +520,12 @@ bool proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
return false;
}
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer want =
((wuffs_base__io_buffer){.ptr = global_want_buffer, .len = BUFFER_SIZE});
if (!gt->src_filename) {
src.closed = true;