From 0b9f9162a5654b98dc780a6554b5247c04af1b98 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Fri, 7 Jul 2017 12:06:54 +1000 Subject: [PATCH] Add std/flate tests. --- gen/c/std/flate.c | 295 +++++++++++++++++++++++++++++++++++ gen/h/std/flate.h | 150 ++++++++++++++++++ std/flate/decode_flate.puffs | 13 ++ test/c/mimiclib/flate.c | 57 +++++++ test/c/std/flate.c | 195 +++++++++++++++++++++++ test/c/std/gif.c | 7 - test/c/testlib/testlib.c | 89 +++++++++++ 7 files changed, 799 insertions(+), 7 deletions(-) create mode 100644 gen/c/std/flate.c create mode 100644 gen/h/std/flate.h create mode 100644 std/flate/decode_flate.puffs create mode 100644 test/c/mimiclib/flate.c create mode 100644 test/c/std/flate.c diff --git a/gen/c/std/flate.c b/gen/c/std/flate.c new file mode 100644 index 00000000..4d732a10 --- /dev/null +++ b/gen/c/std/flate.c @@ -0,0 +1,295 @@ +#ifndef PUFFS_FLATE_H +#define PUFFS_FLATE_H + +// Code generated by puffs-gen-c. DO NOT EDIT. + +#ifndef PUFFS_BASE_HEADER_H +#define PUFFS_BASE_HEADER_H + +// Use of this source code is governed by a BSD-style license that can be found +// in the LICENSE file. + +#include +#include +#include + +// Puffs requires a word size of at least 32 bits because it assumes that +// converting a u32 to usize will never overflow. For example, the size of a +// decoded image is often represented, explicitly or implicitly in an image +// file, as a u32, and it is convenient to compare that to a buffer size. +// +// Similarly, the word size is at most 64 bits because it assumes that +// converting a usize to u64 will never overflow. +#if __WORDSIZE < 32 +#error "Puffs requires a word size of at least 32 bits" +#elif __WORDSIZE > 64 +#error "Puffs requires a word size of at most 64 bits" +#endif + +// PUFFS_VERSION is the major.minor version number as a uint32. The major +// number is the high 16 bits. The minor number is the low 16 bits. +// +// The intention is to bump the version number at least on every API / ABI +// backwards incompatible change. +// +// For now, the API and ABI are simply unstable and can change at any time. +// +// TODO: don't hard code this in base-header.h. +#define PUFFS_VERSION (0x00001) + +// puffs_base_buf1 is a 1-dimensional buffer (a pointer and length) plus +// additional indexes into that buffer. +// +// A value with all fields NULL or zero is a valid, empty buffer. +typedef struct { + uint8_t* ptr; // Pointer. + size_t len; // Length. + size_t wi; // Write index. Invariant: wi <= len. + size_t ri; // Read index. Invariant: ri <= wi. + bool closed; // No further writes are expected. +} puffs_base_buf1; + +// puffs_base_limit1 provides a limited view of a 1-dimensional byte stream: +// its first N bytes. That N can be greater than a buffer's current read or +// write capacity. N decreases naturally over time as bytes are read from or +// written to the stream. +// +// A value with all fields NULL or zero is a valid, unlimited view. +typedef struct puffs_base_limit1 { + uint64_t* ptr_to_len; // Pointer to N. + struct puffs_base_limit1* next; // Linked list of limits. +} puffs_base_limit1; + +typedef struct { + puffs_base_buf1* buf; + puffs_base_limit1 limit; +} puffs_base_reader1; + +typedef struct { + puffs_base_buf1* buf; + puffs_base_limit1 limit; +} puffs_base_writer1; + +#endif // PUFFS_BASE_HEADER_H + +#ifdef __cplusplus +extern "C" { +#endif + +// ---------------- Status Codes + +// Status codes are int32_t values: +// - the sign bit indicates a non-recoverable status code: an error +// - bits 10-30 hold the packageid: a namespace +// - bits 8-9 are reserved +// - bits 0-7 are a package-namespaced numeric code +// +// Do not manipulate these bits directly. Use the API functions such as +// puffs_flate_status_is_error instead. +typedef int32_t puffs_flate_status; + +#define puffs_flate_packageid 967230 // 0x000ec23e + +#define PUFFS_FLATE_STATUS_OK 0 // 0x00000000 +#define PUFFS_FLATE_ERROR_BAD_VERSION -2147483647 // 0x80000001 +#define PUFFS_FLATE_ERROR_BAD_RECEIVER -2147483646 // 0x80000002 +#define PUFFS_FLATE_ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 +#define PUFFS_FLATE_ERROR_CONSTRUCTOR_NOT_CALLED -2147483644 // 0x80000004 +#define PUFFS_FLATE_ERROR_UNEXPECTED_EOF -2147483643 // 0x80000005 +#define PUFFS_FLATE_STATUS_SHORT_READ 6 // 0x00000006 +#define PUFFS_FLATE_STATUS_SHORT_WRITE 7 // 0x00000007 +#define PUFFS_FLATE_ERROR_CLOSED_FOR_WRITES -2147483640 // 0x80000008 + +bool puffs_flate_status_is_error(puffs_flate_status s); + +const char* puffs_flate_status_string(puffs_flate_status s); + +// ---------------- Structs + +typedef struct { + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. Instead, use the + // puffs_flate_decoder_etc functions. + // + // In C++, these fields would be "private", but C does not support that. + // + // It is a struct, not a struct*, so that it can be stack allocated. + struct { + puffs_flate_status status; + uint32_t magic; + + struct { + uint32_t coro_state; + } c_decode[1]; + } private_impl; +} puffs_flate_decoder; + +// ---------------- Public Constructor and Destructor Prototypes + +// puffs_flate_decoder_constructor is a constructor function. +// +// It should be called before any other puffs_flate_decoder_* function. +// +// Pass PUFFS_VERSION and 0 for puffs_version and for_internal_use_only. +void puffs_flate_decoder_constructor(puffs_flate_decoder* self, + uint32_t puffs_version, + uint32_t for_internal_use_only); + +void puffs_flate_decoder_destructor(puffs_flate_decoder* self); + +// ---------------- Public Function Prototypes + +puffs_flate_status puffs_flate_decoder_decode(puffs_flate_decoder* self, + puffs_base_writer1 a_dst, + puffs_base_reader1 a_src); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // PUFFS_FLATE_H + +// C HEADER ENDS HERE. + +#ifndef PUFFS_BASE_IMPL_H +#define PUFFS_BASE_IMPL_H + +// Use of this source code is governed by a BSD-style license that can be found +// in the LICENSE file. + +// Use switch cases for coroutine state, similar to the technique in +// https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html +// +// We use a trivial macro instead of an explicit assignment and case statement +// so that clang-format doesn't get confused by the unusual "case"s. +#define PUFFS_COROUTINE_STATE(n) \ + coro_state = n; \ + case n: + +#define PUFFS_LOW_BITS(x, n) ((x) & ((1 << (n)) - 1)) + +// Clang also defines "__GNUC__". +#if defined(__GNUC__) +#define PUFFS_LIKELY(expr) (__builtin_expect(!!(expr), 1)) +#define PUFFS_UNLIKELY(expr) (__builtin_expect(!!(expr), 0)) +#else +#define PUFFS_LIKELY(expr) (expr) +#define PUFFS_UNLIKELY(expr) (expr) +#endif + +#endif // PUFFS_BASE_IMPL_H + +// ---------------- Status Codes Implementations + +bool puffs_flate_status_is_error(puffs_flate_status s) { + return s < 0; +} + +const char* puffs_flate_status_strings0[9] = { + "flate: ok", + "flate: bad version", + "flate: bad receiver", + "flate: bad argument", + "flate: constructor not called", + "flate: unexpected EOF", + "flate: short read", + "flate: short write", + "flate: closed for writes", +}; + +const char* puffs_flate_status_strings1[0] = {}; + +const char* puffs_flate_status_string(puffs_flate_status s) { + const char** a = NULL; + uint32_t n = 0; + switch ((s >> 10) & 0x1fffff) { + case 0: + a = puffs_flate_status_strings0; + n = 9; + break; + case puffs_flate_packageid: + a = puffs_flate_status_strings1; + n = 0; + break; + } + uint32_t i = s & 0xff; + return i < n ? a[i] : "flate: unknown status"; +} + +// ---------------- Private Constructor and Destructor Prototypes + +// ---------------- Private Function Prototypes + +// ---------------- Constructor and Destructor Implementations + +// PUFFS_MAGIC is a magic number to check that constructors are called. It's +// not foolproof, given C doesn't automatically zero memory before use, but it +// should catch 99.99% of cases. +// +// Its (non-zero) value is arbitrary, based on md5sum("puffs"). +#define PUFFS_MAGIC (0xCB3699CCU) + +// PUFFS_ALREADY_ZEROED is passed from a container struct's constructor to a +// containee struct's constructor when the container has already zeroed the +// containee's memory. +// +// Its (non-zero) value is arbitrary, based on md5sum("zeroed"). +#define PUFFS_ALREADY_ZEROED (0x68602EF1U) + +void puffs_flate_decoder_constructor(puffs_flate_decoder* self, + uint32_t puffs_version, + uint32_t for_internal_use_only) { + if (!self) { + return; + } + if (puffs_version != PUFFS_VERSION) { + self->private_impl.status = PUFFS_FLATE_ERROR_BAD_VERSION; + return; + } + if (for_internal_use_only != PUFFS_ALREADY_ZEROED) { + memset(self, 0, sizeof(*self)); + } + self->private_impl.magic = PUFFS_MAGIC; +} + +void puffs_flate_decoder_destructor(puffs_flate_decoder* self) { + if (!self) { + return; + } +} + +// ---------------- Function Implementations + +puffs_flate_status puffs_flate_decoder_decode(puffs_flate_decoder* self, + puffs_base_writer1 a_dst, + puffs_base_reader1 a_src) { + if (!self) { + return PUFFS_FLATE_ERROR_BAD_RECEIVER; + } + puffs_flate_status status = self->private_impl.status; + if (status < 0) { + return status; + } + if (self->private_impl.magic != PUFFS_MAGIC) { + status = PUFFS_FLATE_ERROR_CONSTRUCTOR_NOT_CALLED; + goto exit; + } + + uint32_t coro_state = self->private_impl.c_decode[0].coro_state; + if (coro_state) { + } + switch (coro_state) { + PUFFS_COROUTINE_STATE(0); + + coro_state = 0; + } + + goto suspend; +suspend: + self->private_impl.c_decode[0].coro_state = coro_state; + + goto exit; +exit: + self->private_impl.status = status; + return status; +} diff --git a/gen/h/std/flate.h b/gen/h/std/flate.h new file mode 100644 index 00000000..afde1b8f --- /dev/null +++ b/gen/h/std/flate.h @@ -0,0 +1,150 @@ +#ifndef PUFFS_FLATE_H +#define PUFFS_FLATE_H + +// Code generated by puffs-gen-c. DO NOT EDIT. + +#ifndef PUFFS_BASE_HEADER_H +#define PUFFS_BASE_HEADER_H + +// Use of this source code is governed by a BSD-style license that can be found +// in the LICENSE file. + +#include +#include +#include + +// Puffs requires a word size of at least 32 bits because it assumes that +// converting a u32 to usize will never overflow. For example, the size of a +// decoded image is often represented, explicitly or implicitly in an image +// file, as a u32, and it is convenient to compare that to a buffer size. +// +// Similarly, the word size is at most 64 bits because it assumes that +// converting a usize to u64 will never overflow. +#if __WORDSIZE < 32 +#error "Puffs requires a word size of at least 32 bits" +#elif __WORDSIZE > 64 +#error "Puffs requires a word size of at most 64 bits" +#endif + +// PUFFS_VERSION is the major.minor version number as a uint32. The major +// number is the high 16 bits. The minor number is the low 16 bits. +// +// The intention is to bump the version number at least on every API / ABI +// backwards incompatible change. +// +// For now, the API and ABI are simply unstable and can change at any time. +// +// TODO: don't hard code this in base-header.h. +#define PUFFS_VERSION (0x00001) + +// puffs_base_buf1 is a 1-dimensional buffer (a pointer and length) plus +// additional indexes into that buffer. +// +// A value with all fields NULL or zero is a valid, empty buffer. +typedef struct { + uint8_t* ptr; // Pointer. + size_t len; // Length. + size_t wi; // Write index. Invariant: wi <= len. + size_t ri; // Read index. Invariant: ri <= wi. + bool closed; // No further writes are expected. +} puffs_base_buf1; + +// puffs_base_limit1 provides a limited view of a 1-dimensional byte stream: +// its first N bytes. That N can be greater than a buffer's current read or +// write capacity. N decreases naturally over time as bytes are read from or +// written to the stream. +// +// A value with all fields NULL or zero is a valid, unlimited view. +typedef struct puffs_base_limit1 { + uint64_t* ptr_to_len; // Pointer to N. + struct puffs_base_limit1* next; // Linked list of limits. +} puffs_base_limit1; + +typedef struct { + puffs_base_buf1* buf; + puffs_base_limit1 limit; +} puffs_base_reader1; + +typedef struct { + puffs_base_buf1* buf; + puffs_base_limit1 limit; +} puffs_base_writer1; + +#endif // PUFFS_BASE_HEADER_H + +#ifdef __cplusplus +extern "C" { +#endif + +// ---------------- Status Codes + +// Status codes are int32_t values: +// - the sign bit indicates a non-recoverable status code: an error +// - bits 10-30 hold the packageid: a namespace +// - bits 8-9 are reserved +// - bits 0-7 are a package-namespaced numeric code +// +// Do not manipulate these bits directly. Use the API functions such as +// puffs_flate_status_is_error instead. +typedef int32_t puffs_flate_status; + +#define puffs_flate_packageid 967230 // 0x000ec23e + +#define PUFFS_FLATE_STATUS_OK 0 // 0x00000000 +#define PUFFS_FLATE_ERROR_BAD_VERSION -2147483647 // 0x80000001 +#define PUFFS_FLATE_ERROR_BAD_RECEIVER -2147483646 // 0x80000002 +#define PUFFS_FLATE_ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 +#define PUFFS_FLATE_ERROR_CONSTRUCTOR_NOT_CALLED -2147483644 // 0x80000004 +#define PUFFS_FLATE_ERROR_UNEXPECTED_EOF -2147483643 // 0x80000005 +#define PUFFS_FLATE_STATUS_SHORT_READ 6 // 0x00000006 +#define PUFFS_FLATE_STATUS_SHORT_WRITE 7 // 0x00000007 +#define PUFFS_FLATE_ERROR_CLOSED_FOR_WRITES -2147483640 // 0x80000008 + +bool puffs_flate_status_is_error(puffs_flate_status s); + +const char* puffs_flate_status_string(puffs_flate_status s); + +// ---------------- Structs + +typedef struct { + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. Instead, use the + // puffs_flate_decoder_etc functions. + // + // In C++, these fields would be "private", but C does not support that. + // + // It is a struct, not a struct*, so that it can be stack allocated. + struct { + puffs_flate_status status; + uint32_t magic; + + struct { + uint32_t coro_state; + } c_decode[1]; + } private_impl; +} puffs_flate_decoder; + +// ---------------- Public Constructor and Destructor Prototypes + +// puffs_flate_decoder_constructor is a constructor function. +// +// It should be called before any other puffs_flate_decoder_* function. +// +// Pass PUFFS_VERSION and 0 for puffs_version and for_internal_use_only. +void puffs_flate_decoder_constructor(puffs_flate_decoder* self, + uint32_t puffs_version, + uint32_t for_internal_use_only); + +void puffs_flate_decoder_destructor(puffs_flate_decoder* self); + +// ---------------- Public Function Prototypes + +puffs_flate_status puffs_flate_decoder_decode(puffs_flate_decoder* self, + puffs_base_writer1 a_dst, + puffs_base_reader1 a_src); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // PUFFS_FLATE_H diff --git a/std/flate/decode_flate.puffs b/std/flate/decode_flate.puffs new file mode 100644 index 00000000..f188cc21 --- /dev/null +++ b/std/flate/decode_flate.puffs @@ -0,0 +1,13 @@ +// Use of this source code is governed by a BSD-style license that can be found +// in the LICENSE file. + +// The flate spec is https://www.ietf.org/rfc/rfc1951.txt + +packageid "flte" + +pub struct decoder?( +) + +pub func decoder.decode?(dst writer1, src reader1)() { + // TODO. +} diff --git a/test/c/mimiclib/flate.c b/test/c/mimiclib/flate.c new file mode 100644 index 00000000..15c9bdc4 --- /dev/null +++ b/test/c/mimiclib/flate.c @@ -0,0 +1,57 @@ +// Use of this source code is governed by a BSD-style license that can be found +// in the LICENSE file. + +#include "zlib.h" + +unsigned int flate_mimic_read_func(void* ctx, unsigned char** buf) { + puffs_base_buf1* src = (puffs_base_buf1*)(ctx); + *buf = src->ptr + src->ri; + return src->wi - src->ri; +} + +int flate_mimic_write_func(void* ctx, unsigned char* ptr, unsigned int len) { + puffs_base_buf1* dst = (puffs_base_buf1*)(ctx); + size_t n = len; + if (n > dst->len - dst->wi) { + return 1; + } + memmove(dst->ptr + dst->wi, ptr, n); + dst->wi += n; + return 0; +} + +const char* flate_mimic_decode(puffs_base_buf1* dst, puffs_base_buf1* src) { + const char* ret = NULL; + uint8_t window[32 * 1024]; + + z_stream z = {0}; + int ibi_err = inflateBackInit(&z, 15, window); + if (ibi_err != Z_OK) { + ret = "inflateBackInit failed"; + goto cleanup0; + } + + int ib_err = + inflateBack(&z, flate_mimic_read_func, src, flate_mimic_write_func, dst); + if (ib_err != Z_STREAM_END) { + ret = "inflateBack failed"; + goto cleanup1; + } + + size_t readable = src->wi - src->ri; + size_t remaining = z.avail_in; + if (readable < remaining) { + ret = "inconsistent avail_in"; + goto cleanup1; + } + src->ri += readable - remaining; + +cleanup1:; + int ibe_err = inflateBackEnd(&z); + if ((ibe_err != Z_OK) && !ret) { + ret = "inflateBackEnd failed"; + } + +cleanup0:; + return ret; +} diff --git a/test/c/std/flate.c b/test/c/std/flate.c new file mode 100644 index 00000000..a11f5e76 --- /dev/null +++ b/test/c/std/flate.c @@ -0,0 +1,195 @@ +// Use of this source code is governed by a BSD-style license that can be found +// in the LICENSE file. + +/* +This test program is typically run indirectly, by the "puffs test" or "puffs +bench" commands. These commands take an optional "-mimic" flag to check that +Puffs' output mimics (i.e. exactly matches) other libraries' output, such as +giflib for GIF, libpng for PNG, etc. + +To manually run this test: + +for cc in clang gcc; do + $cc -std=c99 -Wall -Werror flate.c && ./a.out + rm -f a.out +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 +compiler flags (after the .c file) to run the mimic tests. + +To manually run the benchmarks, replace "-Wall -Werror" with "-O3" and replace +"./a.out" with "./a.out -bench". Combine these changes with the "puffs mimic +cflags" to run the mimic benchmarks. +*/ + +// !! puffs mimic cflags: -DPUFFS_MIMIC -lz + +#include "../../../gen/c/std/flate.c" +#include "../testlib/testlib.c" + +const char* proc_filename = "std/flate.c"; + +// ---------------- Golden Tests + +// The src_offset0 and src_offset1 magic numbers come from: +// +// go run script/extract-flate-offsets.go test/testdata/*.gz +// +// The empty comments forces clang-format to place one element per line. + +golden_test midsummer_gt = { + .want_filename = "../../testdata/midsummer.txt", // + .src_filename = "../../testdata/midsummer.txt.gz", // + .src_offset0 = 24, // + .src_offset1 = 5166, // +}; + +golden_test pi_gt = { + .want_filename = "../../testdata/pi.txt", // + .src_filename = "../../testdata/pi.txt.gz", // + .src_offset0 = 17, // + .src_offset1 = 48335, // +}; + +golden_test romeo_gt = { + .want_filename = "../../testdata/romeo.txt", // + .src_filename = "../../testdata/romeo.txt.gz", // + .src_offset0 = 20, // + .src_offset1 = 550, // +}; + +// ---------------- Flate Tests + +const char* flate_puffs_decode(puffs_base_buf1* dst, puffs_base_buf1* src) { + puffs_flate_decoder dec; + puffs_flate_decoder_constructor(&dec, PUFFS_VERSION, 0); + puffs_base_writer1 dst_writer = {.buf = dst}; + puffs_base_reader1 src_reader = {.buf = src}; + puffs_flate_status s = + puffs_flate_decoder_decode(&dec, dst_writer, src_reader); + puffs_flate_decoder_destructor(&dec); + if (s) { + return puffs_flate_status_string(s); + } + return NULL; +} + +void test_flate_puffs_decode_midsummer() { + proc_funcname = __func__; + test_buf1_buf1(flate_puffs_decode, &midsummer_gt); +} + +void test_flate_puffs_decode_pi() { + proc_funcname = __func__; + test_buf1_buf1(flate_puffs_decode, &pi_gt); +} + +void test_flate_puffs_decode_romeo() { + proc_funcname = __func__; + test_buf1_buf1(flate_puffs_decode, &romeo_gt); +} + +// ---------------- Mimic Tests + +#ifdef PUFFS_MIMIC + +#include "../mimiclib/flate.c" + +void test_flate_mimic_decode_midsummer() { + proc_funcname = __func__; + test_buf1_buf1(flate_mimic_decode, &midsummer_gt); +} + +void test_flate_mimic_decode_pi() { + proc_funcname = __func__; + test_buf1_buf1(flate_mimic_decode, &pi_gt); +} + +void test_flate_mimic_decode_romeo() { + proc_funcname = __func__; + test_buf1_buf1(flate_mimic_decode, &romeo_gt); +} + +#endif // PUFFS_MIMIC + +// ---------------- Flate Benches + +void bench_flate_puffs_decode_1k() { + proc_funcname = __func__; + bench_buf1_buf1(flate_puffs_decode, &romeo_gt, 200000); +} + +void bench_flate_puffs_decode_10k() { + proc_funcname = __func__; + bench_buf1_buf1(flate_puffs_decode, &midsummer_gt, 30000); +} + +void bench_flate_puffs_decode_100k() { + proc_funcname = __func__; + bench_buf1_buf1(flate_puffs_decode, &pi_gt, 3000); +} + +// ---------------- Mimic Benches + +#ifdef PUFFS_MIMIC + +void bench_flate_mimic_decode_1k() { + proc_funcname = __func__; + bench_buf1_buf1(flate_mimic_decode, &romeo_gt, 200000); +} + +void bench_flate_mimic_decode_10k() { + proc_funcname = __func__; + bench_buf1_buf1(flate_mimic_decode, &midsummer_gt, 30000); +} + +void bench_flate_mimic_decode_100k() { + proc_funcname = __func__; + bench_buf1_buf1(flate_mimic_decode, &pi_gt, 3000); +} + +#endif // PUFFS_MIMIC + +// ---------------- Manifest + +// The empty comments forces clang-format to place one element per line. +proc tests[] = { + // Flate Tests + /* TODO: implement flate_puffs, then uncomment these. + test_flate_puffs_decode_midsummer, // + test_flate_puffs_decode_pi, // + test_flate_puffs_decode_romeo, // + */ + +#ifdef PUFFS_MIMIC + + // Mimic Tests + test_flate_mimic_decode_midsummer, // + test_flate_mimic_decode_pi, // + test_flate_mimic_decode_romeo, // + +#endif // PUFFS_MIMIC + + NULL, +}; + +// The empty comments forces clang-format to place one element per line. +proc benches[] = { + // Flate Benches + bench_flate_puffs_decode_1k, // + bench_flate_puffs_decode_10k, // + bench_flate_puffs_decode_100k, // + +#ifdef PUFFS_MIMIC + + // Mimic Benches + bench_flate_mimic_decode_1k, // + bench_flate_mimic_decode_10k, // + bench_flate_mimic_decode_100k, // + +#endif // PUFFS_MIMIC + + NULL, +}; diff --git a/test/c/std/gif.c b/test/c/std/gif.c index 27f18faf..0b5581fb 100644 --- a/test/c/std/gif.c +++ b/test/c/std/gif.c @@ -31,13 +31,6 @@ cflags" to run the mimic benchmarks. const char* proc_filename = "std/gif.c"; -#define BUFFER_SIZE (1024 * 1024) - -uint8_t global_got_buffer[BUFFER_SIZE]; -uint8_t global_want_buffer[BUFFER_SIZE]; -uint8_t global_src_buffer[BUFFER_SIZE]; -uint8_t global_palette_buffer[3 * 256]; - // ---------------- Basic Tests void test_basic_bad_argument_out_of_range() { diff --git a/test/c/testlib/testlib.c b/test/c/testlib/testlib.c index dbcd345e..fa232ca1 100644 --- a/test/c/testlib/testlib.c +++ b/test/c/testlib/testlib.c @@ -7,6 +7,13 @@ #include #include +#define BUFFER_SIZE (1024 * 1024) + +uint8_t global_got_buffer[BUFFER_SIZE]; +uint8_t global_want_buffer[BUFFER_SIZE]; +uint8_t global_src_buffer[BUFFER_SIZE]; +uint8_t global_palette_buffer[3 * 256]; + char fail_msg[65536] = {0}; #define FAIL(...) snprintf(fail_msg, sizeof(fail_msg), ##__VA_ARGS__) @@ -34,6 +41,13 @@ const char* cc = "cl"; const char* cc = "cc"; #endif +typedef struct { + const char* want_filename; + const char* src_filename; + size_t src_offset0; + size_t src_offset1; +} golden_test; + bool bench_warm_up; struct timeval bench_start_tv; @@ -249,4 +263,79 @@ bool buf1s_equal(const char* prefix, return false; } +void proc_buf1_buf1(const char* (*codec_func)(puffs_base_buf1*, + puffs_base_buf1*), + golden_test* gt, + uint64_t reps, + bool bench) { + if (!codec_func) { + FAIL("NULL codec_func"); + return; + } + if (!gt) { + FAIL("NULL golden_test"); + return; + } + + 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}; + + if (!read_file(&src, gt->src_filename)) { + return; + } + if (gt->src_offset0 || gt->src_offset1) { + if (gt->src_offset0 > gt->src_offset1) { + FAIL("inconsistent src_offsets"); + return; + } + if (gt->src_offset1 > src.wi) { + FAIL("src_offset1 too large"); + return; + } + src.ri = gt->src_offset0; + src.wi = gt->src_offset1; + } + + if (bench) { + bench_start(); + } + uint64_t n_bytes = 0; + uint64_t i; + for (i = 0; i < reps; i++) { + got.wi = 0; + src.ri = gt->src_offset0; + const char* s = codec_func(&got, &src); + if (s) { + FAIL("%s", s); + return; + } + n_bytes += got.wi; + } + if (bench) { + bench_finish(reps, n_bytes); + return; + } + + if (!read_file(&want, gt->want_filename)) { + return; + } + if (!buf1s_equal("", &got, &want)) { + return; + } +} + +void bench_buf1_buf1(const char* (*codec_func)(puffs_base_buf1*, + puffs_base_buf1*), + golden_test* gt, + uint64_t reps) { + proc_buf1_buf1(codec_func, gt, reps, true); +} + +void test_buf1_buf1(const char* (*codec_func)(puffs_base_buf1*, + puffs_base_buf1*), + golden_test* gt) { + proc_buf1_buf1(codec_func, gt, 1, false); +} + #endif // PUFFS_BASE_HEADER_H