mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 08:32:11 +01:00
Re-format C function signatures
This commit is contained in:
1 parent
51b1258b61
commit
2914bae3b2
26 files changed
+833
-532
No files matched your search
@@ -56,7 +56,8 @@ for a C++ compiler $CXX, such as clang++ or g++.
|
||||
|
||||
uint8_t src_buffer[SRC_BUFFER_SIZE];
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
wuffs_crc32__ieee_hasher h;
|
||||
wuffs_base__status status = h.initialize(sizeof h, WUFFS_VERSION, 0);
|
||||
if (!status.is_ok()) {
|
||||
|
||||
@@ -44,7 +44,8 @@ support true color: https://gist.github.com/XVilka/8346728
|
||||
bool started = false;
|
||||
struct timespec start_time = {0};
|
||||
|
||||
int64_t micros_since_start(struct timespec* now) {
|
||||
int64_t //
|
||||
micros_since_start(struct timespec* now) {
|
||||
if (!started) {
|
||||
return 0;
|
||||
}
|
||||
@@ -105,7 +106,8 @@ wuffs_base__pixel_buffer pb = {0};
|
||||
|
||||
wuffs_base__flicks cumulative_delay_micros = 0;
|
||||
|
||||
const char* read_stdin() {
|
||||
const char* //
|
||||
read_stdin() {
|
||||
while (src_len < SRC_BUFFER_SIZE) {
|
||||
size_t n = fread(src_buffer + src_len, sizeof(uint8_t),
|
||||
SRC_BUFFER_SIZE - src_len, stdin);
|
||||
@@ -133,7 +135,8 @@ bool color_flag = false;
|
||||
bool quirk_honor_background_color_flag = false;
|
||||
const int stdout_fd = 1;
|
||||
|
||||
static inline uint32_t load_u32le(uint8_t* p) {
|
||||
static inline uint32_t //
|
||||
load_u32le(uint8_t* p) {
|
||||
return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |
|
||||
((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);
|
||||
}
|
||||
@@ -146,9 +149,10 @@ store_u32le(uint8_t* p, uint32_t x) {
|
||||
p[3] = (uint8_t)(x >> 24);
|
||||
}
|
||||
|
||||
void restore_background(wuffs_base__pixel_buffer* pb,
|
||||
wuffs_base__rect_ie_u32 bounds,
|
||||
wuffs_base__color_u32_argb_premul background_color) {
|
||||
void //
|
||||
restore_background(wuffs_base__pixel_buffer* pb,
|
||||
wuffs_base__rect_ie_u32 bounds,
|
||||
wuffs_base__color_u32_argb_premul background_color) {
|
||||
size_t width4 = (size_t)(wuffs_base__pixel_config__width(&pb->pixcfg)) * 4;
|
||||
size_t y;
|
||||
for (y = bounds.min_incl_y; y < bounds.max_excl_y; y++) {
|
||||
@@ -161,7 +165,8 @@ void restore_background(wuffs_base__pixel_buffer* pb,
|
||||
}
|
||||
}
|
||||
|
||||
size_t print_ascii_art(wuffs_base__pixel_buffer* pb) {
|
||||
size_t //
|
||||
print_ascii_art(wuffs_base__pixel_buffer* pb) {
|
||||
uint32_t width = wuffs_base__pixel_config__width(&pb->pixcfg);
|
||||
uint32_t height = wuffs_base__pixel_config__height(&pb->pixcfg);
|
||||
|
||||
@@ -188,7 +193,8 @@ size_t print_ascii_art(wuffs_base__pixel_buffer* pb) {
|
||||
return p - printbuf.ptr;
|
||||
}
|
||||
|
||||
size_t print_color_art(wuffs_base__pixel_buffer* pb) {
|
||||
size_t //
|
||||
print_color_art(wuffs_base__pixel_buffer* pb) {
|
||||
uint32_t width = wuffs_base__pixel_config__width(&pb->pixcfg);
|
||||
uint32_t height = wuffs_base__pixel_config__height(&pb->pixcfg);
|
||||
|
||||
@@ -217,7 +223,8 @@ size_t print_color_art(wuffs_base__pixel_buffer* pb) {
|
||||
|
||||
// ----
|
||||
|
||||
const char* try_allocate(wuffs_gif__decoder* dec) {
|
||||
const char* //
|
||||
try_allocate(wuffs_gif__decoder* dec) {
|
||||
uint32_t width = wuffs_base__pixel_config__width(&ic.pixcfg);
|
||||
uint32_t height = wuffs_base__pixel_config__height(&ic.pixcfg);
|
||||
uint64_t num_pixels = ((uint64_t)width) * ((uint64_t)height);
|
||||
@@ -260,7 +267,8 @@ const char* try_allocate(wuffs_gif__decoder* dec) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* allocate(wuffs_gif__decoder* dec) {
|
||||
const char* //
|
||||
allocate(wuffs_gif__decoder* dec) {
|
||||
const char* status_msg = try_allocate(dec);
|
||||
if (status_msg) {
|
||||
free(printbuf.ptr);
|
||||
@@ -276,7 +284,8 @@ const char* allocate(wuffs_gif__decoder* dec) {
|
||||
return status_msg;
|
||||
}
|
||||
|
||||
const char* play() {
|
||||
const char* //
|
||||
play() {
|
||||
wuffs_gif__decoder dec;
|
||||
wuffs_base__status status =
|
||||
wuffs_gif__decoder__initialize(&dec, sizeof dec, WUFFS_VERSION, 0);
|
||||
@@ -427,7 +436,8 @@ const char* play() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
int i;
|
||||
for (i = 1; i < argc; i++) {
|
||||
if (!strcmp(argv[i], "-color")) {
|
||||
|
||||
@@ -96,14 +96,16 @@ union {
|
||||
wuffs_wbmp__decoder wbmp;
|
||||
} g_potential_decoders;
|
||||
|
||||
static inline void store_u32le(uint8_t* p, uint32_t x) {
|
||||
static inline void //
|
||||
store_u32le(uint8_t* p, uint32_t x) {
|
||||
p[0] = (uint8_t)(x >> 0);
|
||||
p[1] = (uint8_t)(x >> 8);
|
||||
p[2] = (uint8_t)(x >> 16);
|
||||
p[3] = (uint8_t)(x >> 24);
|
||||
}
|
||||
|
||||
bool read_more_src() {
|
||||
bool //
|
||||
read_more_src() {
|
||||
if (g_src.meta.closed) {
|
||||
printf("%s: unexpected end of file\n", g_filename);
|
||||
return false;
|
||||
@@ -120,7 +122,8 @@ bool read_more_src() {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool load_image_type() {
|
||||
bool //
|
||||
load_image_type() {
|
||||
while (g_src.meta.wi == 0) {
|
||||
if (!read_more_src()) {
|
||||
return false;
|
||||
@@ -175,7 +178,8 @@ bool load_image_type() {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool load_image_config() {
|
||||
bool //
|
||||
load_image_config() {
|
||||
// Decode the wuffs_base__image_config.
|
||||
while (true) {
|
||||
wuffs_base__status status = wuffs_base__image_decoder__decode_image_config(
|
||||
@@ -262,7 +266,8 @@ bool load_image_config() {
|
||||
|
||||
// This function always returns true. If we get this far, we still display a
|
||||
// partial image, even if we encounter an error.
|
||||
bool load_image_frame() {
|
||||
bool //
|
||||
load_image_frame() {
|
||||
while (true) {
|
||||
wuffs_base__status status = wuffs_base__image_decoder__decode_frame(
|
||||
g_image_decoder, &g_pixbuf, &g_src, WUFFS_BASE__PIXEL_BLEND__SRC_OVER,
|
||||
@@ -286,7 +291,8 @@ bool load_image_frame() {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool load_image(const char* filename) {
|
||||
bool //
|
||||
load_image(const char* filename) {
|
||||
if (g_workbuf_slice.ptr != NULL) {
|
||||
free(g_workbuf_slice.ptr);
|
||||
g_workbuf_slice.ptr = NULL;
|
||||
@@ -348,14 +354,16 @@ xcb_pixmap_t g_pixmap = XCB_NONE;
|
||||
xcb_keysym_t* g_keysyms = NULL;
|
||||
xcb_get_keyboard_mapping_reply_t* g_keyboard_mapping = NULL;
|
||||
|
||||
void init_keymap(xcb_connection_t* c, const xcb_setup_t* z) {
|
||||
void //
|
||||
init_keymap(xcb_connection_t* c, const xcb_setup_t* z) {
|
||||
xcb_get_keyboard_mapping_cookie_t cookie = xcb_get_keyboard_mapping(
|
||||
c, z->min_keycode, z->max_keycode - z->min_keycode + 1);
|
||||
g_keyboard_mapping = xcb_get_keyboard_mapping_reply(c, cookie, NULL);
|
||||
g_keysyms = (xcb_keysym_t*)(g_keyboard_mapping + 1);
|
||||
}
|
||||
|
||||
xcb_window_t make_window(xcb_connection_t* c, xcb_screen_t* s) {
|
||||
xcb_window_t //
|
||||
make_window(xcb_connection_t* c, xcb_screen_t* s) {
|
||||
xcb_window_t w = xcb_generate_id(c);
|
||||
uint32_t value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
|
||||
uint32_t value_list[2];
|
||||
@@ -372,11 +380,12 @@ xcb_window_t make_window(xcb_connection_t* c, xcb_screen_t* s) {
|
||||
return w;
|
||||
}
|
||||
|
||||
bool load(xcb_connection_t* c,
|
||||
xcb_screen_t* s,
|
||||
xcb_window_t w,
|
||||
xcb_gcontext_t g,
|
||||
const char* filename) {
|
||||
bool //
|
||||
load(xcb_connection_t* c,
|
||||
xcb_screen_t* s,
|
||||
xcb_window_t w,
|
||||
xcb_gcontext_t g,
|
||||
const char* filename) {
|
||||
if (g_pixmap != XCB_NONE) {
|
||||
xcb_free_pixmap(c, g_pixmap);
|
||||
}
|
||||
@@ -394,7 +403,8 @@ bool load(xcb_connection_t* c,
|
||||
return true;
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
xcb_connection_t* c = xcb_connect(NULL, NULL);
|
||||
const xcb_setup_t* z = xcb_get_setup(c);
|
||||
xcb_screen_t* s = xcb_setup_roots_iterator(z).data;
|
||||
@@ -508,7 +518,8 @@ int main(int argc, char** argv) {
|
||||
|
||||
#if !defined(SUPPORTED_OPERATING_SYSTEM)
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
printf("unsupported operating system\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
+24
-14
@@ -101,7 +101,8 @@ size_t indent;
|
||||
|
||||
// ----
|
||||
|
||||
const char* read_src() {
|
||||
const char* //
|
||||
read_src() {
|
||||
if (src.meta.closed) {
|
||||
return "main: internal error: read requested on a closed source";
|
||||
}
|
||||
@@ -119,7 +120,8 @@ const char* read_src() {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const char* flush_dst() {
|
||||
const char* //
|
||||
flush_dst() {
|
||||
size_t n = dst.meta.wi - dst.meta.ri;
|
||||
if (n > 0) {
|
||||
size_t i = fwrite(dst.data.ptr + dst.meta.ri, sizeof(uint8_t), n, stdout);
|
||||
@@ -132,7 +134,8 @@ const char* flush_dst() {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const char* write_dst(const void* s, size_t n) {
|
||||
const char* //
|
||||
write_dst(const void* s, size_t n) {
|
||||
const uint8_t* p = static_cast<const uint8_t*>(s);
|
||||
while (n > 0) {
|
||||
size_t i = dst.writer_available();
|
||||
@@ -181,7 +184,8 @@ typedef struct {
|
||||
wuffs_base__slice_u8 data;
|
||||
} parsed_token;
|
||||
|
||||
parsed_token make_pt_error(const char* error_msg) {
|
||||
parsed_token //
|
||||
make_pt_error(const char* error_msg) {
|
||||
parsed_token p;
|
||||
p.error_msg = error_msg;
|
||||
p.token = wuffs_base__make_token(0);
|
||||
@@ -189,9 +193,8 @@ parsed_token make_pt_error(const char* error_msg) {
|
||||
return p;
|
||||
}
|
||||
|
||||
parsed_token make_pt_token(uint64_t token_repr,
|
||||
uint8_t* data_ptr,
|
||||
size_t data_len) {
|
||||
parsed_token //
|
||||
make_pt_token(uint64_t token_repr, uint8_t* data_ptr, size_t data_len) {
|
||||
parsed_token p;
|
||||
p.error_msg = nullptr;
|
||||
p.token = wuffs_base__make_token(token_repr);
|
||||
@@ -199,7 +202,8 @@ parsed_token make_pt_token(uint64_t token_repr,
|
||||
return p;
|
||||
}
|
||||
|
||||
parsed_token parse_next_token() {
|
||||
parsed_token //
|
||||
parse_next_token() {
|
||||
while (true) {
|
||||
// Return a previously produced token, if one exists.
|
||||
//
|
||||
@@ -254,7 +258,8 @@ parsed_token parse_next_token() {
|
||||
|
||||
// ----
|
||||
|
||||
uint8_t hex_digit(uint8_t nibble) {
|
||||
uint8_t //
|
||||
hex_digit(uint8_t nibble) {
|
||||
nibble &= 0x0F;
|
||||
if (nibble <= 9) {
|
||||
return '0' + nibble;
|
||||
@@ -262,7 +267,8 @@ uint8_t hex_digit(uint8_t nibble) {
|
||||
return ('A' - 10) + nibble;
|
||||
}
|
||||
|
||||
const char* handle_string(parsed_token pt) {
|
||||
const char* //
|
||||
handle_string(parsed_token pt) {
|
||||
TRY(write_dst("\"", 1));
|
||||
while (true) {
|
||||
uint64_t vbc = pt.token.value_base_category();
|
||||
@@ -365,7 +371,8 @@ const char* handle_string(parsed_token pt) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const char* main2() {
|
||||
const char* //
|
||||
main2() {
|
||||
dec_status = dec.initialize(sizeof__wuffs_json__decoder(), WUFFS_VERSION, 0);
|
||||
if (!dec_status.is_ok()) {
|
||||
return dec_status.message();
|
||||
@@ -515,7 +522,8 @@ break_loop:
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const char* main1(int argc, char** argv) {
|
||||
const char* //
|
||||
main1(int argc, char** argv) {
|
||||
dst = wuffs_base__make_io_buffer(
|
||||
wuffs_base__make_slice_u8(dst_buffer, DST_BUFFER_SIZE),
|
||||
wuffs_base__empty_io_buffer_meta());
|
||||
@@ -535,7 +543,8 @@ const char* main1(int argc, char** argv) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
int compute_exit_code(const char* status_msg) {
|
||||
int //
|
||||
compute_exit_code(const char* status_msg) {
|
||||
if (!status_msg) {
|
||||
return 0;
|
||||
}
|
||||
@@ -559,7 +568,8 @@ int compute_exit_code(const char* status_msg) {
|
||||
return strstr(status_msg, "internal error:") ? 2 : 1;
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
const char* z0 = main1(argc, argv);
|
||||
const char* z1 = flush_dst();
|
||||
int exit_code = compute_exit_code(z0 ? z0 : z1);
|
||||
|
||||
@@ -76,7 +76,8 @@ uint8_t work_buffer[WORK_BUFFER_SIZE];
|
||||
uint8_t work_buffer[1];
|
||||
#endif
|
||||
|
||||
static const char* decode() {
|
||||
static const char* //
|
||||
decode() {
|
||||
wuffs_base__io_buffer dst;
|
||||
dst.data.ptr = dst_buffer;
|
||||
dst.data.len = DST_BUFFER_SIZE;
|
||||
@@ -117,7 +118,8 @@ static const char* decode() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
const char* status_msg = decode();
|
||||
if (status_msg) {
|
||||
fprintf(stderr, "%s\n", status_msg);
|
||||
|
||||
+8
-4
@@ -81,9 +81,11 @@ uint8_t work_buffer[1];
|
||||
#endif
|
||||
|
||||
// ignore_return_value suppresses errors from -Wall -Werror.
|
||||
static void ignore_return_value(int ignored) {}
|
||||
static void //
|
||||
ignore_return_value(int ignored) {}
|
||||
|
||||
static const char* decode() {
|
||||
static const char* //
|
||||
decode() {
|
||||
wuffs_gzip__decoder dec;
|
||||
wuffs_base__status status =
|
||||
wuffs_gzip__decoder__initialize(&dec, sizeof dec, WUFFS_VERSION, 0);
|
||||
@@ -151,7 +153,8 @@ static const char* decode() {
|
||||
}
|
||||
}
|
||||
|
||||
int compute_exit_code(const char* status_msg) {
|
||||
int //
|
||||
compute_exit_code(const char* status_msg) {
|
||||
if (!status_msg) {
|
||||
return 0;
|
||||
}
|
||||
@@ -177,7 +180,8 @@ int compute_exit_code(const char* status_msg) {
|
||||
return strstr(status_msg, "internal error:") ? 2 : 1;
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
#if defined(WUFFS_EXAMPLE_USE_SECCOMP)
|
||||
prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);
|
||||
#endif
|
||||
|
||||
@@ -23,13 +23,16 @@
|
||||
|
||||
volatile int* intentional_segfault_ptr = NULL;
|
||||
|
||||
void intentional_segfault() {
|
||||
void //
|
||||
intentional_segfault() {
|
||||
*intentional_segfault_ptr = 0;
|
||||
}
|
||||
|
||||
const char* fuzz(wuffs_base__io_buffer* src, uint32_t hash);
|
||||
const char* //
|
||||
fuzz(wuffs_base__io_buffer* src, uint32_t hash);
|
||||
|
||||
static const char* llvmFuzzerTestOneInput(const uint8_t* data, size_t size) {
|
||||
static const char* //
|
||||
llvmFuzzerTestOneInput(const uint8_t* data, size_t size) {
|
||||
// Hash input as per https://en.wikipedia.org/wiki/Jenkins_hash_function
|
||||
size_t i = 0;
|
||||
uint32_t hash = 0;
|
||||
@@ -72,7 +75,8 @@ static const char* llvmFuzzerTestOneInput(const uint8_t* data, size_t size) {
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
|
||||
int //
|
||||
LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
|
||||
llvmFuzzerTestOneInput(data, size);
|
||||
return 0;
|
||||
}
|
||||
@@ -98,9 +102,11 @@ static struct {
|
||||
size_t len;
|
||||
} relative_cwd;
|
||||
|
||||
static int visit(char* filename);
|
||||
static int //
|
||||
visit(char* filename);
|
||||
|
||||
static int visit_dir(int fd) {
|
||||
static int //
|
||||
visit_dir(int fd) {
|
||||
int cwd_fd = open(".", O_RDONLY, 0);
|
||||
if (fchdir(fd)) {
|
||||
printf("failed\n");
|
||||
@@ -145,7 +151,8 @@ static int visit_dir(int fd) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int visit_reg(int fd, off_t size) {
|
||||
static int //
|
||||
visit_reg(int fd, off_t size) {
|
||||
if ((size < 0) || (0x7FFFFFFF < size)) {
|
||||
printf("failed\n");
|
||||
fprintf(stderr, "FAIL: file size out of bounds");
|
||||
@@ -179,7 +186,8 @@ static int visit_reg(int fd, off_t size) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int visit(char* filename) {
|
||||
static int //
|
||||
visit(char* filename) {
|
||||
num_files_processed++;
|
||||
if (!filename || (filename[0] == '\x00')) {
|
||||
fprintf(stderr, "FAIL: invalid filename\n");
|
||||
@@ -235,7 +243,8 @@ static int visit(char* filename) {
|
||||
return v;
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
num_files_processed = 0;
|
||||
relative_cwd.len = 0;
|
||||
|
||||
|
||||
@@ -48,7 +48,8 @@ It should print "PASS", amongst other information, and exit(0).
|
||||
#include "../../../release/c/wuffs-unsupported-snapshot.c"
|
||||
#include "../fuzzlib/fuzzlib.c"
|
||||
|
||||
const char* fuzz(wuffs_base__io_buffer* src, uint32_t hash) {
|
||||
const char* //
|
||||
fuzz(wuffs_base__io_buffer* src, uint32_t hash) {
|
||||
const char* ret = NULL;
|
||||
wuffs_base__slice_u8 pixbuf = ((wuffs_base__slice_u8){});
|
||||
wuffs_base__slice_u8 workbuf = ((wuffs_base__slice_u8){});
|
||||
|
||||
@@ -60,7 +60,8 @@ uint8_t work_buffer[WORK_BUFFER_SIZE];
|
||||
uint8_t work_buffer[1];
|
||||
#endif
|
||||
|
||||
const char* fuzz(wuffs_base__io_buffer* src, uint32_t hash) {
|
||||
const char* //
|
||||
fuzz(wuffs_base__io_buffer* src, uint32_t hash) {
|
||||
wuffs_zlib__decoder dec;
|
||||
wuffs_base__status status = wuffs_zlib__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
|
||||
@@ -53,7 +53,8 @@ const char* cc = "cc";
|
||||
const char* cc_version = "???";
|
||||
#endif
|
||||
|
||||
static uint32_t calculate_hash(uint8_t* x_ptr, size_t x_len) {
|
||||
static uint32_t //
|
||||
calculate_hash(uint8_t* x_ptr, size_t x_len) {
|
||||
uint32_t s1 = 1;
|
||||
uint32_t s2 = 0;
|
||||
|
||||
@@ -115,7 +116,8 @@ static uint32_t calculate_hash(uint8_t* x_ptr, size_t x_len) {
|
||||
|
||||
uint8_t buffer[BUFFER_SIZE] = {0};
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
bool nocheck = false;
|
||||
int i;
|
||||
for (i = 0; i < argc; i++) {
|
||||
|
||||
@@ -88,7 +88,8 @@ const char* cc = "cc";
|
||||
const char* cc_version = "???";
|
||||
#endif
|
||||
|
||||
static inline uint32_t load_u32be(uint8_t* p) {
|
||||
static inline uint32_t //
|
||||
load_u32be(uint8_t* p) {
|
||||
return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) |
|
||||
((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0);
|
||||
}
|
||||
@@ -126,7 +127,8 @@ uint64_t bytes_per_pixel = 0;
|
||||
uint64_t bytes_per_row = 0;
|
||||
uint64_t bytes_per_frame = 0;
|
||||
|
||||
const char* read_stdin() {
|
||||
const char* //
|
||||
read_stdin() {
|
||||
while (src_len < SRC_BUFFER_SIZE) {
|
||||
const int stdin_fd = 0;
|
||||
ssize_t n = read(stdin_fd, src_buffer + src_len, SRC_BUFFER_SIZE - src_len);
|
||||
@@ -143,7 +145,8 @@ const char* read_stdin() {
|
||||
return "input is too large";
|
||||
}
|
||||
|
||||
const char* process_png_chunks(uint8_t* p, size_t n) {
|
||||
const char* //
|
||||
process_png_chunks(uint8_t* p, size_t n) {
|
||||
while (n > 0) {
|
||||
// Process the 8 byte chunk header.
|
||||
if (n < 8) {
|
||||
@@ -225,7 +228,8 @@ const char* process_png_chunks(uint8_t* p, size_t n) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* decode_once(bool frag_dst, bool frag_idat) {
|
||||
const char* //
|
||||
decode_once(bool frag_dst, bool frag_idat) {
|
||||
wuffs_zlib__decoder dec;
|
||||
wuffs_base__status status =
|
||||
wuffs_zlib__decoder__initialize(&dec, sizeof dec, WUFFS_VERSION, 0);
|
||||
@@ -295,7 +299,8 @@ const char* decode_once(bool frag_dst, bool frag_idat) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* decode(bool frag_dst, bool frag_idat) {
|
||||
const char* //
|
||||
decode(bool frag_dst, bool frag_idat) {
|
||||
int reps;
|
||||
if (bytes_per_frame < 100000) {
|
||||
reps = 1000;
|
||||
@@ -336,14 +341,16 @@ const char* decode(bool frag_dst, bool frag_idat) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int fail(const char* msg) {
|
||||
int //
|
||||
fail(const char* msg) {
|
||||
const int stderr_fd = 2;
|
||||
write(stderr_fd, msg, strnlen(msg, 4095));
|
||||
write(stderr_fd, "\n", 1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
const char* msg = read_stdin();
|
||||
if (msg) {
|
||||
return fail(msg);
|
||||
|
||||
@@ -66,13 +66,15 @@
|
||||
// recent. For some reason, this #include hits "No such file or directory" on
|
||||
// Ubuntu 18.04 (linux 4.15, glibc 2.27), and there's also been problems on
|
||||
// Debian systems. Instead, we explicitly define our own memfd_create.
|
||||
static int my_memfd_create(const char* name, unsigned int flags) {
|
||||
static int //
|
||||
my_memfd_create(const char* name, unsigned int flags) {
|
||||
return syscall(__NR_memfd_create, name, flags);
|
||||
}
|
||||
|
||||
#define N (128 * 1024)
|
||||
|
||||
void* make_ring_buffer() {
|
||||
void* //
|
||||
make_ring_buffer() {
|
||||
int page_size = getpagesize();
|
||||
if ((N < page_size) || (page_size <= 0) || ((N % page_size) != 0)) {
|
||||
return NULL;
|
||||
@@ -105,7 +107,8 @@ void* make_ring_buffer() {
|
||||
return base;
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
uint8_t* base = make_ring_buffer();
|
||||
if (!base) {
|
||||
fprintf(stderr, "could not make ring buffer\n");
|
||||
|
||||
@@ -165,10 +165,10 @@ const char*
|
||||
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state =
|
||||
"?deflate: internal error: inconsistent Huffman decoder state";
|
||||
|
||||
static wuffs_base__status wuffs_deflate__decoder__decode_huffman_fast(
|
||||
wuffs_deflate__decoder* self,
|
||||
wuffs_base__io_buffer* a_dst,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
static wuffs_base__status //
|
||||
wuffs_deflate__decoder__decode_huffman_fast(wuffs_deflate__decoder* self,
|
||||
wuffs_base__io_buffer* a_dst,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
|
||||
@@ -217,16 +217,16 @@ static const uint32_t wuffs_base__width_to_mask_table[33] = {
|
||||
|
||||
// This is the generated function that we are explicitly overriding. Note that
|
||||
// the function name is "wuffs_etc", not "c_wuffs_etc".
|
||||
static wuffs_base__status wuffs_deflate__decoder__decode_huffman_fast(
|
||||
wuffs_deflate__decoder* self,
|
||||
wuffs_base__io_buffer* a_dst,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
static wuffs_base__status //
|
||||
wuffs_deflate__decoder__decode_huffman_fast(wuffs_deflate__decoder* self,
|
||||
wuffs_base__io_buffer* a_dst,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
// This is the overriding implementation.
|
||||
wuffs_base__status c_wuffs_deflate__decoder__decode_huffman_fast(
|
||||
wuffs_deflate__decoder* self,
|
||||
wuffs_base__io_buffer* a_dst,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status //
|
||||
c_wuffs_deflate__decoder__decode_huffman_fast(wuffs_deflate__decoder* self,
|
||||
wuffs_base__io_buffer* a_dst,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
// Avoid the -Werror=unused-function warning for the now-unused
|
||||
// overridden wuffs_deflate__decoder__decode_huffman_fast.
|
||||
(void)(wuffs_deflate__decoder__decode_huffman_fast);
|
||||
|
||||
@@ -20,28 +20,31 @@
|
||||
#ifdef WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB
|
||||
#include "/path/to/your/copy/of/github.com/richgel999/miniz/miniz_tinfl.c"
|
||||
|
||||
const char* mimic_bench_adler32(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
mimic_bench_adler32(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
return "miniz does not independently compute Adler32";
|
||||
}
|
||||
|
||||
const char* mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
return "miniz does not implement CRC32/IEEE";
|
||||
}
|
||||
|
||||
const char* mimic_deflate_zlib_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit,
|
||||
bool deflate_instead_of_zlib) {
|
||||
const char* //
|
||||
mimic_deflate_zlib_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit,
|
||||
bool deflate_instead_of_zlib) {
|
||||
if ((wlimit < UINT64_MAX) || (rlimit < UINT64_MAX)) {
|
||||
// Supporting this would probably mean using tinfl_decompress instead of
|
||||
// the simpler tinfl_decompress_mem_to_mem function.
|
||||
@@ -62,35 +65,39 @@ const char* mimic_deflate_zlib_decode(wuffs_base__io_buffer* dst,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* mimic_deflate_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
mimic_deflate_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
return mimic_deflate_zlib_decode(dst, src, wuffs_initialize_flags, wlimit,
|
||||
rlimit, true);
|
||||
}
|
||||
|
||||
const char* mimic_gzip_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
mimic_gzip_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
return "miniz does not implement gzip";
|
||||
}
|
||||
|
||||
const char* mimic_zlib_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
mimic_zlib_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
return mimic_deflate_zlib_decode(dst, src, wuffs_initialize_flags, wlimit,
|
||||
rlimit, false);
|
||||
}
|
||||
|
||||
const char* mimic_zlib_decode_with_dictionary(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
wuffs_base__slice_u8 dictionary) {
|
||||
const char* //
|
||||
mimic_zlib_decode_with_dictionary(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
wuffs_base__slice_u8 dictionary) {
|
||||
return "miniz does not implement zlib dictionaries";
|
||||
}
|
||||
|
||||
@@ -99,11 +106,12 @@ const char* mimic_zlib_decode_with_dictionary(wuffs_base__io_buffer* dst,
|
||||
|
||||
uint32_t global_mimiclib_deflate_unused_u32;
|
||||
|
||||
const char* mimic_bench_adler32(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
mimic_bench_adler32(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
global_mimiclib_deflate_unused_u32 = 0;
|
||||
while (src->meta.ri < src->meta.wi) {
|
||||
uint8_t* ptr = src->data.ptr + src->meta.ri;
|
||||
@@ -120,11 +128,12 @@ const char* mimic_bench_adler32(wuffs_base__io_buffer* dst,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
global_mimiclib_deflate_unused_u32 = 0;
|
||||
while (src->meta.ri < src->meta.wi) {
|
||||
uint8_t* ptr = src->data.ptr + src->meta.ri;
|
||||
@@ -147,12 +156,13 @@ typedef enum {
|
||||
zlib_flavor_zlib,
|
||||
} zlib_flavor;
|
||||
|
||||
const char* mimic_deflate_gzip_zlib_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
wuffs_base__slice_u8* dictionary,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit,
|
||||
zlib_flavor flavor) {
|
||||
const char* //
|
||||
mimic_deflate_gzip_zlib_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
wuffs_base__slice_u8* dictionary,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit,
|
||||
zlib_flavor flavor) {
|
||||
const char* ret = NULL;
|
||||
if (dst->data.len > UINT_MAX) {
|
||||
ret = "dst length is too large";
|
||||
@@ -251,36 +261,40 @@ cleanup0:;
|
||||
return ret;
|
||||
}
|
||||
|
||||
const char* mimic_deflate_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
mimic_deflate_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
return mimic_deflate_gzip_zlib_decode(dst, src, NULL, wlimit, rlimit,
|
||||
zlib_flavor_raw);
|
||||
}
|
||||
|
||||
const char* mimic_gzip_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
mimic_gzip_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
return mimic_deflate_gzip_zlib_decode(dst, src, NULL, wlimit, rlimit,
|
||||
zlib_flavor_gzip);
|
||||
}
|
||||
|
||||
const char* mimic_zlib_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
mimic_zlib_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
return mimic_deflate_gzip_zlib_decode(dst, src, NULL, wlimit, rlimit,
|
||||
zlib_flavor_zlib);
|
||||
}
|
||||
|
||||
const char* mimic_zlib_decode_with_dictionary(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
wuffs_base__slice_u8 dictionary) {
|
||||
const char* //
|
||||
mimic_zlib_decode_with_dictionary(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
wuffs_base__slice_u8 dictionary) {
|
||||
return mimic_deflate_gzip_zlib_decode(dst, src, &dictionary, UINT64_MAX,
|
||||
UINT64_MAX, zlib_flavor_zlib);
|
||||
}
|
||||
|
||||
@@ -14,7 +14,8 @@
|
||||
|
||||
#include "gif_lib.h"
|
||||
|
||||
int mimic_gif_read_func(GifFileType* f, GifByteType* ptr, int len) {
|
||||
int //
|
||||
mimic_gif_read_func(GifFileType* f, GifByteType* ptr, int len) {
|
||||
wuffs_base__io_buffer* src = (wuffs_base__io_buffer*)(f->UserData);
|
||||
if (len < 0) {
|
||||
return 0;
|
||||
@@ -29,10 +30,11 @@ int mimic_gif_read_func(GifFileType* f, GifByteType* ptr, int len) {
|
||||
return n;
|
||||
}
|
||||
|
||||
const char* mimic_gif_decode(wuffs_base__io_buffer* dst,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
wuffs_base__pixel_format pixfmt,
|
||||
wuffs_base__io_buffer* src) {
|
||||
const char* //
|
||||
mimic_gif_decode(wuffs_base__io_buffer* dst,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
wuffs_base__pixel_format pixfmt,
|
||||
wuffs_base__io_buffer* src) {
|
||||
const char* ret = NULL;
|
||||
|
||||
// http://giflib.sourceforge.net/gif_lib.html#compatibility says that "A few
|
||||
|
||||
+22
-13
@@ -79,7 +79,8 @@ golden_test adler32_pi_gt = {
|
||||
|
||||
// ---------------- Adler32 Tests
|
||||
|
||||
const char* test_wuffs_adler32_interface() {
|
||||
const char* //
|
||||
test_wuffs_adler32_interface() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_adler32__hasher h;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -91,7 +92,8 @@ const char* test_wuffs_adler32_interface() {
|
||||
"test/data/hat.lossy.webp", 0, SIZE_MAX, 0xF1BB258D);
|
||||
}
|
||||
|
||||
const char* test_wuffs_adler32_golden() {
|
||||
const char* //
|
||||
test_wuffs_adler32_golden() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
struct {
|
||||
@@ -171,7 +173,8 @@ const char* test_wuffs_adler32_golden() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_adler32_pi() {
|
||||
const char* //
|
||||
test_wuffs_adler32_pi() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
const char* digits =
|
||||
@@ -229,11 +232,12 @@ const char* test_wuffs_adler32_pi() {
|
||||
|
||||
uint32_t global_wuffs_adler32_unused_u32;
|
||||
|
||||
const char* wuffs_bench_adler32(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
wuffs_bench_adler32(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
uint64_t len = src->meta.wi - src->meta.ri;
|
||||
if (rlimit) {
|
||||
len = wuffs_base__u64__min(len, rlimit);
|
||||
@@ -251,7 +255,8 @@ const char* wuffs_bench_adler32(wuffs_base__io_buffer* dst,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* bench_wuffs_adler32_10k() {
|
||||
const char* //
|
||||
bench_wuffs_adler32_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_bench_adler32,
|
||||
@@ -259,7 +264,8 @@ const char* bench_wuffs_adler32_10k() {
|
||||
&adler32_midsummer_gt, UINT64_MAX, UINT64_MAX, 1500);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_adler32_100k() {
|
||||
const char* //
|
||||
bench_wuffs_adler32_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_bench_adler32,
|
||||
@@ -271,14 +277,16 @@ const char* bench_wuffs_adler32_100k() {
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
const char* bench_mimic_adler32_10k() {
|
||||
const char* //
|
||||
bench_mimic_adler32_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_bench_adler32, 0, tcounter_src,
|
||||
&adler32_midsummer_gt, UINT64_MAX, UINT64_MAX,
|
||||
1500);
|
||||
}
|
||||
|
||||
const char* bench_mimic_adler32_100k() {
|
||||
const char* //
|
||||
bench_mimic_adler32_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_bench_adler32, 0, tcounter_src,
|
||||
&adler32_pi_gt, UINT64_MAX, UINT64_MAX, 150);
|
||||
@@ -317,7 +325,8 @@ proc benches[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/adler32";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
}
|
||||
+6
-3
@@ -69,7 +69,8 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
|
||||
|
||||
// ---------------- BMP Tests
|
||||
|
||||
const char* test_wuffs_bmp_decode_interface() {
|
||||
const char* //
|
||||
test_wuffs_bmp_decode_interface() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_bmp__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -81,7 +82,8 @@ const char* test_wuffs_bmp_decode_interface() {
|
||||
"test/data/hippopotamus.bmp", 0, SIZE_MAX, 36, 28, 0xFFF5F5F5);
|
||||
}
|
||||
|
||||
const char* test_wuffs_bmp_decode_frame_config() {
|
||||
const char* //
|
||||
test_wuffs_bmp_decode_frame_config() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_bmp__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -161,7 +163,8 @@ proc benches[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/bmp";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
}
|
||||
+26
-15
@@ -79,7 +79,8 @@ golden_test crc32_pi_gt = {
|
||||
|
||||
// ---------------- CRC32 Tests
|
||||
|
||||
const char* test_wuffs_crc32_ieee_interface() {
|
||||
const char* //
|
||||
test_wuffs_crc32_ieee_interface() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_crc32__ieee_hasher h;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -91,7 +92,8 @@ const char* test_wuffs_crc32_ieee_interface() {
|
||||
"test/data/hat.lossy.webp", 0, SIZE_MAX, 0x89F53B4E);
|
||||
}
|
||||
|
||||
const char* test_wuffs_crc32_ieee_golden() {
|
||||
const char* //
|
||||
test_wuffs_crc32_ieee_golden() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
struct {
|
||||
@@ -171,7 +173,8 @@ const char* test_wuffs_crc32_ieee_golden() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* do_test_xxxxx_crc32_ieee_pi(bool mimic) {
|
||||
const char* //
|
||||
do_test_xxxxx_crc32_ieee_pi(bool mimic) {
|
||||
const char* digits =
|
||||
"3."
|
||||
"141592653589793238462643383279502884197169399375105820974944592307816406"
|
||||
@@ -244,7 +247,8 @@ const char* do_test_xxxxx_crc32_ieee_pi(bool mimic) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_crc32_ieee_pi() {
|
||||
const char* //
|
||||
test_wuffs_crc32_ieee_pi() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_xxxxx_crc32_ieee_pi(false);
|
||||
}
|
||||
@@ -253,7 +257,8 @@ const char* test_wuffs_crc32_ieee_pi() {
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
const char* test_mimic_crc32_ieee_pi() {
|
||||
const char* //
|
||||
test_mimic_crc32_ieee_pi() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_xxxxx_crc32_ieee_pi(true);
|
||||
}
|
||||
@@ -264,11 +269,12 @@ const char* test_mimic_crc32_ieee_pi() {
|
||||
|
||||
uint32_t global_wuffs_crc32_unused_u32;
|
||||
|
||||
const char* wuffs_bench_crc32_ieee(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
wuffs_bench_crc32_ieee(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
uint64_t len = src->meta.wi - src->meta.ri;
|
||||
if (rlimit) {
|
||||
len = wuffs_base__u64__min(len, rlimit);
|
||||
@@ -286,7 +292,8 @@ const char* wuffs_bench_crc32_ieee(wuffs_base__io_buffer* dst,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* bench_wuffs_crc32_ieee_10k() {
|
||||
const char* //
|
||||
bench_wuffs_crc32_ieee_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_bench_crc32_ieee,
|
||||
@@ -294,7 +301,8 @@ const char* bench_wuffs_crc32_ieee_10k() {
|
||||
&crc32_midsummer_gt, UINT64_MAX, UINT64_MAX, 1500);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_crc32_ieee_100k() {
|
||||
const char* //
|
||||
bench_wuffs_crc32_ieee_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_bench_crc32_ieee,
|
||||
@@ -306,13 +314,15 @@ const char* bench_wuffs_crc32_ieee_100k() {
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
const char* bench_mimic_crc32_ieee_10k() {
|
||||
const char* //
|
||||
bench_mimic_crc32_ieee_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_bench_crc32_ieee, 0, tcounter_src,
|
||||
&crc32_midsummer_gt, UINT64_MAX, UINT64_MAX, 1500);
|
||||
}
|
||||
|
||||
const char* bench_mimic_crc32_ieee_100k() {
|
||||
const char* //
|
||||
bench_mimic_crc32_ieee_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_bench_crc32_ieee, 0, tcounter_src,
|
||||
&crc32_pi_gt, UINT64_MAX, UINT64_MAX, 150);
|
||||
@@ -357,7 +367,8 @@ proc benches[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/crc32";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
}
|
||||
+95
-53
@@ -155,7 +155,8 @@ golden_test deflate_romeo_fixed_gt = {
|
||||
|
||||
// ---------------- Deflate Tests
|
||||
|
||||
const char* test_wuffs_deflate_decode_interface() {
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_interface() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_deflate__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -167,11 +168,12 @@ const char* test_wuffs_deflate_decode_interface() {
|
||||
"test/data/romeo.txt.deflate", 0, SIZE_MAX, 942, 0x0A);
|
||||
}
|
||||
|
||||
const char* wuffs_deflate_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
wuffs_deflate_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
wuffs_deflate__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_deflate__decoder__initialize(
|
||||
@@ -197,34 +199,39 @@ const char* wuffs_deflate_decode(wuffs_base__io_buffer* dst,
|
||||
}
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_decode_256_bytes() {
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_256_bytes() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &deflate_256_bytes_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_decode_deflate_backref_crosses_blocks() {
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_deflate_backref_crosses_blocks() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode,
|
||||
&deflate_deflate_backref_crosses_blocks_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_decode_deflate_degenerate_huffman_unused() {
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_deflate_degenerate_huffman_unused() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode,
|
||||
&deflate_deflate_degenerate_huffman_unused_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_decode_deflate_distance_32768() {
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_deflate_distance_32768() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode,
|
||||
&deflate_deflate_distance_32768_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_decode_deflate_distance_code_31() {
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_deflate_distance_code_31() {
|
||||
CHECK_FOCUS(__func__);
|
||||
const char* have = do_test_io_buffers(wuffs_deflate_decode,
|
||||
&deflate_deflate_distance_code_31_gt,
|
||||
@@ -236,7 +243,8 @@ const char* test_wuffs_deflate_decode_deflate_distance_code_31() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_decode_deflate_huffman_primlen_9() {
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_deflate_huffman_primlen_9() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
// First, treat this like any other compare-to-golden test.
|
||||
@@ -282,48 +290,56 @@ const char* test_wuffs_deflate_decode_deflate_huffman_primlen_9() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_decode_midsummer() {
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_midsummer() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &deflate_midsummer_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_decode_pi_just_one_read() {
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_pi_just_one_read() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_decode_pi_many_big_reads() {
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_pi_many_big_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, UINT64_MAX,
|
||||
4096);
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_decode_pi_many_medium_reads() {
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_pi_many_medium_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, UINT64_MAX,
|
||||
599);
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_decode_pi_many_small_writes_reads() {
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_pi_many_small_writes_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 59, 61);
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_decode_romeo() {
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_romeo() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &deflate_romeo_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_decode_romeo_fixed() {
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_romeo_fixed() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode, &deflate_romeo_fixed_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_decode_split_src() {
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_split_src() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
@@ -382,14 +398,15 @@ const char* test_wuffs_deflate_decode_split_src() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* do_test_wuffs_deflate_history(int i,
|
||||
golden_test* gt,
|
||||
wuffs_base__io_buffer* src,
|
||||
wuffs_base__io_buffer* have,
|
||||
wuffs_deflate__decoder* dec,
|
||||
uint32_t starting_history_index,
|
||||
uint64_t wlimit,
|
||||
const char* want_z) {
|
||||
const char* //
|
||||
do_test_wuffs_deflate_history(int i,
|
||||
golden_test* gt,
|
||||
wuffs_base__io_buffer* src,
|
||||
wuffs_base__io_buffer* have,
|
||||
wuffs_deflate__decoder* dec,
|
||||
uint32_t starting_history_index,
|
||||
uint64_t wlimit,
|
||||
const char* want_z) {
|
||||
src->meta.ri = gt->src_offset0;
|
||||
src->meta.wi = gt->src_offset1;
|
||||
have->meta.ri = 0;
|
||||
@@ -410,7 +427,8 @@ const char* do_test_wuffs_deflate_history(int i,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_history_full() {
|
||||
const char* //
|
||||
test_wuffs_deflate_history_full() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
@@ -472,7 +490,8 @@ const char* test_wuffs_deflate_history_full() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_history_partial() {
|
||||
const char* //
|
||||
test_wuffs_deflate_history_partial() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
@@ -538,7 +557,8 @@ const char* test_wuffs_deflate_history_partial() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_deflate_table_redirect() {
|
||||
const char* //
|
||||
test_wuffs_deflate_table_redirect() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
// Call init_huff with a Huffman code that looks like:
|
||||
@@ -670,34 +690,39 @@ const char* test_wuffs_deflate_table_redirect() {
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
const char* test_mimic_deflate_decode_256_bytes() {
|
||||
const char* //
|
||||
test_mimic_deflate_decode_256_bytes() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode, &deflate_256_bytes_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_mimic_deflate_decode_deflate_backref_crosses_blocks() {
|
||||
const char* //
|
||||
test_mimic_deflate_decode_deflate_backref_crosses_blocks() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode,
|
||||
&deflate_deflate_backref_crosses_blocks_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_mimic_deflate_decode_deflate_degenerate_huffman_unused() {
|
||||
const char* //
|
||||
test_mimic_deflate_decode_deflate_degenerate_huffman_unused() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode,
|
||||
&deflate_deflate_degenerate_huffman_unused_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_mimic_deflate_decode_deflate_distance_32768() {
|
||||
const char* //
|
||||
test_mimic_deflate_decode_deflate_distance_32768() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode,
|
||||
&deflate_deflate_distance_32768_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_mimic_deflate_decode_deflate_distance_code_31() {
|
||||
const char* //
|
||||
test_mimic_deflate_decode_deflate_distance_code_31() {
|
||||
CHECK_FOCUS(__func__);
|
||||
const char* have = do_test_io_buffers(mimic_deflate_decode,
|
||||
&deflate_deflate_distance_code_31_gt,
|
||||
@@ -710,38 +735,44 @@ const char* test_mimic_deflate_decode_deflate_distance_code_31() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_mimic_deflate_decode_deflate_huffman_primlen_9() {
|
||||
const char* //
|
||||
test_mimic_deflate_decode_deflate_huffman_primlen_9() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode,
|
||||
&deflate_deflate_huffman_primlen_9_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_mimic_deflate_decode_midsummer() {
|
||||
const char* //
|
||||
test_mimic_deflate_decode_midsummer() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode, &deflate_midsummer_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_mimic_deflate_decode_pi_just_one_read() {
|
||||
const char* //
|
||||
test_mimic_deflate_decode_pi_just_one_read() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode, &deflate_pi_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_mimic_deflate_decode_pi_many_big_reads() {
|
||||
const char* //
|
||||
test_mimic_deflate_decode_pi_many_big_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode, &deflate_pi_gt, UINT64_MAX,
|
||||
4096);
|
||||
}
|
||||
|
||||
const char* test_mimic_deflate_decode_romeo() {
|
||||
const char* //
|
||||
test_mimic_deflate_decode_romeo() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode, &deflate_romeo_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_mimic_deflate_decode_romeo_fixed() {
|
||||
const char* //
|
||||
test_mimic_deflate_decode_romeo_fixed() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode, &deflate_romeo_fixed_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
@@ -751,14 +782,16 @@ const char* test_mimic_deflate_decode_romeo_fixed() {
|
||||
|
||||
// ---------------- Deflate Benches
|
||||
|
||||
const char* bench_wuffs_deflate_decode_1k_full_init() {
|
||||
const char* //
|
||||
bench_wuffs_deflate_decode_1k_full_init() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(wuffs_deflate_decode,
|
||||
WUFFS_INITIALIZE__DEFAULT_OPTIONS, tcounter_dst,
|
||||
&deflate_romeo_gt, UINT64_MAX, UINT64_MAX, 2000);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_deflate_decode_1k_part_init() {
|
||||
const char* //
|
||||
bench_wuffs_deflate_decode_1k_part_init() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_deflate_decode,
|
||||
@@ -766,14 +799,16 @@ const char* bench_wuffs_deflate_decode_1k_part_init() {
|
||||
&deflate_romeo_gt, UINT64_MAX, UINT64_MAX, 2000);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_deflate_decode_10k_full_init() {
|
||||
const char* //
|
||||
bench_wuffs_deflate_decode_10k_full_init() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_deflate_decode, WUFFS_INITIALIZE__DEFAULT_OPTIONS, tcounter_dst,
|
||||
&deflate_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_deflate_decode_10k_part_init() {
|
||||
const char* //
|
||||
bench_wuffs_deflate_decode_10k_part_init() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_deflate_decode,
|
||||
@@ -781,7 +816,8 @@ const char* bench_wuffs_deflate_decode_10k_part_init() {
|
||||
&deflate_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_deflate_decode_100k_just_one_read() {
|
||||
const char* //
|
||||
bench_wuffs_deflate_decode_100k_just_one_read() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_deflate_decode,
|
||||
@@ -789,7 +825,8 @@ const char* bench_wuffs_deflate_decode_100k_just_one_read() {
|
||||
&deflate_pi_gt, UINT64_MAX, UINT64_MAX, 30);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_deflate_decode_100k_many_big_reads() {
|
||||
const char* //
|
||||
bench_wuffs_deflate_decode_100k_many_big_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_deflate_decode,
|
||||
@@ -801,26 +838,30 @@ const char* bench_wuffs_deflate_decode_100k_many_big_reads() {
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
const char* bench_mimic_deflate_decode_1k() {
|
||||
const char* //
|
||||
bench_mimic_deflate_decode_1k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_deflate_decode, 0, tcounter_dst,
|
||||
&deflate_romeo_gt, UINT64_MAX, UINT64_MAX, 2000);
|
||||
}
|
||||
|
||||
const char* bench_mimic_deflate_decode_10k() {
|
||||
const char* //
|
||||
bench_mimic_deflate_decode_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_deflate_decode, 0, tcounter_dst,
|
||||
&deflate_midsummer_gt, UINT64_MAX, UINT64_MAX,
|
||||
300);
|
||||
}
|
||||
|
||||
const char* bench_mimic_deflate_decode_100k_just_one_read() {
|
||||
const char* //
|
||||
bench_mimic_deflate_decode_100k_just_one_read() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_deflate_decode, 0, tcounter_dst,
|
||||
&deflate_pi_gt, UINT64_MAX, UINT64_MAX, 30);
|
||||
}
|
||||
|
||||
const char* bench_mimic_deflate_decode_100k_many_big_reads() {
|
||||
const char* //
|
||||
bench_mimic_deflate_decode_100k_many_big_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_deflate_decode, 0, tcounter_dst,
|
||||
&deflate_pi_gt, UINT64_MAX, 4096, 30);
|
||||
@@ -893,7 +934,8 @@ proc benches[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/deflate";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
}
|
||||
+185
-102
@@ -70,7 +70,8 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
|
||||
|
||||
// ---------------- Basic Tests
|
||||
|
||||
const char* test_basic_bad_receiver() {
|
||||
const char* //
|
||||
test_basic_bad_receiver() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__image_config ic = ((wuffs_base__image_config){});
|
||||
wuffs_base__status status =
|
||||
@@ -82,7 +83,8 @@ const char* test_basic_bad_receiver() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_basic_bad_sizeof_receiver() {
|
||||
const char* //
|
||||
test_basic_bad_sizeof_receiver() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_gif__decoder dec;
|
||||
wuffs_base__status status = wuffs_gif__decoder__initialize(
|
||||
@@ -95,7 +97,8 @@ const char* test_basic_bad_sizeof_receiver() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_basic_bad_wuffs_version() {
|
||||
const char* //
|
||||
test_basic_bad_wuffs_version() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_gif__decoder dec;
|
||||
wuffs_base__status status = wuffs_gif__decoder__initialize(
|
||||
@@ -108,7 +111,8 @@ const char* test_basic_bad_wuffs_version() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_basic_initialize_not_called() {
|
||||
const char* //
|
||||
test_basic_initialize_not_called() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_gif__decoder dec = ((wuffs_gif__decoder){});
|
||||
wuffs_base__image_config ic = ((wuffs_base__image_config){});
|
||||
@@ -121,7 +125,8 @@ const char* test_basic_initialize_not_called() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_basic_status_is_error() {
|
||||
const char* //
|
||||
test_basic_status_is_error() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__status status;
|
||||
status.repr = NULL;
|
||||
@@ -143,7 +148,8 @@ const char* test_basic_status_is_error() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_basic_sub_struct_initializer() {
|
||||
const char* //
|
||||
test_basic_sub_struct_initializer() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_gif__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -163,7 +169,8 @@ const char* test_basic_sub_struct_initializer() {
|
||||
|
||||
// ---------------- GIF Tests
|
||||
|
||||
const char* test_wuffs_gif_decode_interface_image_config_decoder() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_interface_image_config_decoder() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_gif__config_decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -175,7 +182,8 @@ const char* test_wuffs_gif_decode_interface_image_config_decoder() {
|
||||
"test/data/animated-red-blue.gif", 0, SIZE_MAX, 4);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_interface_image_decoder() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_interface_image_decoder() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_gif__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -187,10 +195,11 @@ const char* test_wuffs_gif_decode_interface_image_decoder() {
|
||||
"test/data/bricks-nodither.gif", 0, SIZE_MAX, 160, 120, 0xFF012463);
|
||||
}
|
||||
|
||||
const char* wuffs_gif_decode(wuffs_base__io_buffer* dst,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
wuffs_base__pixel_format pixfmt,
|
||||
wuffs_base__io_buffer* src) {
|
||||
const char* //
|
||||
wuffs_gif_decode(wuffs_base__io_buffer* dst,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
wuffs_base__pixel_format pixfmt,
|
||||
wuffs_base__io_buffer* src) {
|
||||
wuffs_gif__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_gif__decoder__initialize(&dec, sizeof dec, WUFFS_VERSION,
|
||||
@@ -229,11 +238,12 @@ const char* wuffs_gif_decode(wuffs_base__io_buffer* dst,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* do_test_wuffs_gif_decode(const char* filename,
|
||||
const char* palette_filename,
|
||||
const char* indexes_filename,
|
||||
uint64_t rlimit,
|
||||
wuffs_base__pixel_format dst_pixfmt) {
|
||||
const char* //
|
||||
do_test_wuffs_gif_decode(const char* filename,
|
||||
const char* palette_filename,
|
||||
const char* indexes_filename,
|
||||
uint64_t rlimit,
|
||||
wuffs_base__pixel_format dst_pixfmt) {
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
});
|
||||
@@ -459,10 +469,11 @@ const char* do_test_wuffs_gif_decode(const char* filename,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* do_test_wuffs_gif_decode_expecting(wuffs_base__io_buffer src,
|
||||
uint32_t quirk,
|
||||
const char* want_status,
|
||||
bool want_dirty_rect_is_empty) {
|
||||
const char* //
|
||||
do_test_wuffs_gif_decode_expecting(wuffs_base__io_buffer src,
|
||||
uint32_t quirk,
|
||||
const char* want_status,
|
||||
bool want_dirty_rect_is_empty) {
|
||||
wuffs_gif__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_gif__decoder__initialize(
|
||||
@@ -497,7 +508,8 @@ const char* do_test_wuffs_gif_decode_expecting(wuffs_base__io_buffer src,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_call_interleaved() {
|
||||
const char* //
|
||||
test_wuffs_gif_call_interleaved() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -537,7 +549,8 @@ const char* test_wuffs_gif_call_interleaved() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_call_sequence() {
|
||||
const char* //
|
||||
test_wuffs_gif_call_sequence() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -562,7 +575,8 @@ const char* test_wuffs_gif_call_sequence() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* do_test_wuffs_gif_decode_animated(
|
||||
const char* //
|
||||
do_test_wuffs_gif_decode_animated(
|
||||
const char* filename,
|
||||
uint32_t want_num_loops,
|
||||
uint32_t want_num_frames,
|
||||
@@ -649,19 +663,22 @@ const char* do_test_wuffs_gif_decode_animated(
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_animated_big() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_animated_big() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_decode_animated("test/data/gifplayer-muybridge.gif",
|
||||
0, 380, NULL);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_animated_medium() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_animated_medium() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_decode_animated("test/data/muybridge.gif", 0, 15,
|
||||
NULL);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_animated_small() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_animated_small() {
|
||||
CHECK_FOCUS(__func__);
|
||||
// animated-red-blue.gif's num_loops should be 3. The value explicitly in the
|
||||
// wire format is 0x0002, but that value means "repeat 2 times after the
|
||||
@@ -679,7 +696,8 @@ const char* test_wuffs_gif_decode_animated_small() {
|
||||
want_frame_config_bounds);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_delay_num_frames_decoded() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_delay_num_frames_decoded() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -728,7 +746,8 @@ const char* test_wuffs_gif_decode_delay_num_frames_decoded() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_empty_palette() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_empty_palette() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -795,7 +814,8 @@ const char* test_wuffs_gif_decode_empty_palette() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_background_color() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_background_color() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -833,7 +853,8 @@ const char* test_wuffs_gif_decode_background_color() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_first_frame_is_opaque() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_first_frame_is_opaque() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -870,7 +891,8 @@ const char* test_wuffs_gif_decode_first_frame_is_opaque() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_frame_out_of_bounds() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_frame_out_of_bounds() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -1039,7 +1061,8 @@ const char* test_wuffs_gif_decode_frame_out_of_bounds() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_zero_width_frame() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_zero_width_frame() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -1097,7 +1120,8 @@ const char* test_wuffs_gif_decode_zero_width_frame() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_pixfmt_bgr() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_pixfmt_bgr() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_decode(
|
||||
"test/data/bricks-dither.gif", "test/data/bricks-dither.palette",
|
||||
@@ -1105,7 +1129,8 @@ const char* test_wuffs_gif_decode_pixfmt_bgr() {
|
||||
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGR));
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_pixfmt_bgr_565() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_pixfmt_bgr_565() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_decode(
|
||||
"test/data/bricks-dither.gif", "test/data/bricks-dither.palette",
|
||||
@@ -1113,7 +1138,8 @@ const char* test_wuffs_gif_decode_pixfmt_bgr_565() {
|
||||
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGR_565));
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_pixfmt_bgra_nonpremul() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_pixfmt_bgra_nonpremul() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_decode(
|
||||
"test/data/bricks-dither.gif", "test/data/bricks-dither.palette",
|
||||
@@ -1121,7 +1147,8 @@ const char* test_wuffs_gif_decode_pixfmt_bgra_nonpremul() {
|
||||
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL));
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_pixfmt_rgb() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_pixfmt_rgb() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_decode(
|
||||
"test/data/bricks-dither.gif", "test/data/bricks-dither.palette",
|
||||
@@ -1129,7 +1156,8 @@ const char* test_wuffs_gif_decode_pixfmt_rgb() {
|
||||
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__RGB));
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_pixfmt_rgba_nonpremul() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_pixfmt_rgba_nonpremul() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_decode(
|
||||
"test/data/bricks-dither.gif", "test/data/bricks-dither.palette",
|
||||
@@ -1137,7 +1165,8 @@ const char* test_wuffs_gif_decode_pixfmt_rgba_nonpremul() {
|
||||
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL));
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_input_is_a_gif_just_one_read() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_input_is_a_gif_just_one_read() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_decode(
|
||||
"test/data/bricks-dither.gif", "test/data/bricks-dither.palette",
|
||||
@@ -1146,7 +1175,8 @@ const char* test_wuffs_gif_decode_input_is_a_gif_just_one_read() {
|
||||
WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY));
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_input_is_a_gif_many_big_reads() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_input_is_a_gif_many_big_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_decode(
|
||||
"test/data/bricks-dither.gif", "test/data/bricks-dither.palette",
|
||||
@@ -1155,7 +1185,8 @@ const char* test_wuffs_gif_decode_input_is_a_gif_many_big_reads() {
|
||||
WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY));
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_input_is_a_gif_many_medium_reads() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_input_is_a_gif_many_medium_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_decode(
|
||||
"test/data/bricks-dither.gif", "test/data/bricks-dither.palette",
|
||||
@@ -1168,7 +1199,8 @@ const char* test_wuffs_gif_decode_input_is_a_gif_many_medium_reads() {
|
||||
// TODO: has 787 changed since we decode the image_config separately?
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_input_is_a_gif_many_small_reads() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_input_is_a_gif_many_small_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_decode(
|
||||
"test/data/bricks-dither.gif", "test/data/bricks-dither.palette",
|
||||
@@ -1177,7 +1209,8 @@ const char* test_wuffs_gif_decode_input_is_a_gif_many_small_reads() {
|
||||
WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY));
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_input_is_a_png() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_input_is_a_png() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -1200,7 +1233,8 @@ const char* test_wuffs_gif_decode_input_is_a_png() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_interlaced_truncated() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_interlaced_truncated() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -1422,17 +1456,20 @@ const char* do_test_wuffs_gif_decode_metadata(bool full) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_metadata_empty() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_metadata_empty() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_decode_metadata(false);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_metadata_full() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_metadata_full() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_decode_metadata(true);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_missing_two_src_bytes() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_missing_two_src_bytes() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -1449,7 +1486,8 @@ const char* test_wuffs_gif_decode_missing_two_src_bytes() {
|
||||
src, 0, wuffs_base__suspension__short_read, false);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_multiple_graphic_controls() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_multiple_graphic_controls() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -1475,7 +1513,8 @@ const char* test_wuffs_gif_decode_multiple_graphic_controls() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_multiple_loop_counts() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_multiple_loop_counts() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -1536,7 +1575,8 @@ const char* test_wuffs_gif_decode_multiple_loop_counts() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_pixel_data_none() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_pixel_data_none() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -1547,7 +1587,8 @@ const char* test_wuffs_gif_decode_pixel_data_none() {
|
||||
src, 0, wuffs_base__error__not_enough_data, true);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_pixel_data_not_enough() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_pixel_data_not_enough() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -1559,7 +1600,8 @@ const char* test_wuffs_gif_decode_pixel_data_not_enough() {
|
||||
src, 0, wuffs_base__error__not_enough_data, false);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_pixel_data_too_much_sans_quirk() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_pixel_data_too_much_sans_quirk() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -1571,7 +1613,8 @@ const char* test_wuffs_gif_decode_pixel_data_too_much_sans_quirk() {
|
||||
src, 0, wuffs_base__error__too_much_data, false);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_decode_pixel_data_too_much_with_quirk() {
|
||||
const char* //
|
||||
test_wuffs_gif_decode_pixel_data_too_much_with_quirk() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -1583,7 +1626,8 @@ const char* test_wuffs_gif_decode_pixel_data_too_much_with_quirk() {
|
||||
src, WUFFS_GIF__QUIRK_IGNORE_TOO_MUCH_PIXEL_DATA, NULL, false);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_frame_dirty_rect() {
|
||||
const char* //
|
||||
test_wuffs_gif_frame_dirty_rect() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -1705,12 +1749,14 @@ const char* do_test_wuffs_gif_num_decoded(bool frame_config) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_num_decoded_frame_configs() {
|
||||
const char* //
|
||||
test_wuffs_gif_num_decoded_frame_configs() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_num_decoded(true);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_num_decoded_frames() {
|
||||
const char* //
|
||||
test_wuffs_gif_num_decoded_frames() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_num_decoded(false);
|
||||
}
|
||||
@@ -1867,17 +1913,20 @@ const char* do_test_wuffs_gif_io_position(bool chunked) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_io_position_one_chunk() {
|
||||
const char* //
|
||||
test_wuffs_gif_io_position_one_chunk() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_io_position(false);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_io_position_two_chunks() {
|
||||
const char* //
|
||||
test_wuffs_gif_io_position_two_chunks() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gif_io_position(true);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_small_frame_interlaced() {
|
||||
const char* //
|
||||
test_wuffs_gif_small_frame_interlaced() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
@@ -1931,7 +1980,8 @@ const char* test_wuffs_gif_small_frame_interlaced() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gif_sizeof() {
|
||||
const char* //
|
||||
test_wuffs_gif_sizeof() {
|
||||
CHECK_FOCUS(__func__);
|
||||
size_t n0 = sizeof(wuffs_gif__config_decoder);
|
||||
size_t n1 = sizeof(wuffs_gif__decoder);
|
||||
@@ -1983,67 +2033,80 @@ const char* do_test_mimic_gif_decode(const char* filename) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_mimic_gif_decode_animated_small() {
|
||||
const char* //
|
||||
test_mimic_gif_decode_animated_small() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_mimic_gif_decode("test/data/animated-red-blue.gif");
|
||||
}
|
||||
|
||||
const char* test_mimic_gif_decode_bricks_dither() {
|
||||
const char* //
|
||||
test_mimic_gif_decode_bricks_dither() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_mimic_gif_decode("test/data/bricks-dither.gif");
|
||||
}
|
||||
|
||||
const char* test_mimic_gif_decode_bricks_gray() {
|
||||
const char* //
|
||||
test_mimic_gif_decode_bricks_gray() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_mimic_gif_decode("test/data/bricks-gray.gif");
|
||||
}
|
||||
|
||||
const char* test_mimic_gif_decode_bricks_nodither() {
|
||||
const char* //
|
||||
test_mimic_gif_decode_bricks_nodither() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_mimic_gif_decode("test/data/bricks-nodither.gif");
|
||||
}
|
||||
|
||||
const char* test_mimic_gif_decode_gifplayer_muybridge() {
|
||||
const char* //
|
||||
test_mimic_gif_decode_gifplayer_muybridge() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_mimic_gif_decode("test/data/gifplayer-muybridge.gif");
|
||||
}
|
||||
|
||||
const char* test_mimic_gif_decode_harvesters() {
|
||||
const char* //
|
||||
test_mimic_gif_decode_harvesters() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_mimic_gif_decode("test/data/harvesters.gif");
|
||||
}
|
||||
|
||||
const char* test_mimic_gif_decode_hat() {
|
||||
const char* //
|
||||
test_mimic_gif_decode_hat() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_mimic_gif_decode("test/data/hat.gif");
|
||||
}
|
||||
|
||||
const char* test_mimic_gif_decode_hibiscus_primitive() {
|
||||
const char* //
|
||||
test_mimic_gif_decode_hibiscus_primitive() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_mimic_gif_decode("test/data/hibiscus.primitive.gif");
|
||||
}
|
||||
|
||||
const char* test_mimic_gif_decode_hibiscus_regular() {
|
||||
const char* //
|
||||
test_mimic_gif_decode_hibiscus_regular() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_mimic_gif_decode("test/data/hibiscus.regular.gif");
|
||||
}
|
||||
|
||||
const char* test_mimic_gif_decode_hippopotamus_interlaced() {
|
||||
const char* //
|
||||
test_mimic_gif_decode_hippopotamus_interlaced() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_mimic_gif_decode("test/data/hippopotamus.interlaced.gif");
|
||||
}
|
||||
|
||||
const char* test_mimic_gif_decode_hippopotamus_regular() {
|
||||
const char* //
|
||||
test_mimic_gif_decode_hippopotamus_regular() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_mimic_gif_decode("test/data/hippopotamus.regular.gif");
|
||||
}
|
||||
|
||||
const char* test_mimic_gif_decode_muybridge() {
|
||||
const char* //
|
||||
test_mimic_gif_decode_muybridge() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_mimic_gif_decode("test/data/muybridge.gif");
|
||||
}
|
||||
|
||||
const char* test_mimic_gif_decode_pjw_thumbnail() {
|
||||
const char* //
|
||||
test_mimic_gif_decode_pjw_thumbnail() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_mimic_gif_decode("test/data/pjw-thumbnail.gif");
|
||||
}
|
||||
@@ -2052,15 +2115,15 @@ const char* test_mimic_gif_decode_pjw_thumbnail() {
|
||||
|
||||
// ---------------- GIF Benches
|
||||
|
||||
const char* do_bench_gif_decode(
|
||||
const char* (*decode_func)(wuffs_base__io_buffer*,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
wuffs_base__pixel_format,
|
||||
wuffs_base__io_buffer*),
|
||||
uint32_t wuffs_initialize_flags,
|
||||
const char* filename,
|
||||
wuffs_base__pixel_format pixfmt,
|
||||
uint64_t iters_unscaled) {
|
||||
const char* //
|
||||
do_bench_gif_decode(const char* (*decode_func)(wuffs_base__io_buffer*,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
wuffs_base__pixel_format,
|
||||
wuffs_base__io_buffer*),
|
||||
uint32_t wuffs_initialize_flags,
|
||||
const char* filename,
|
||||
wuffs_base__pixel_format pixfmt,
|
||||
uint64_t iters_unscaled) {
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
});
|
||||
@@ -2083,7 +2146,8 @@ const char* do_bench_gif_decode(
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* bench_wuffs_gif_decode_1k_bw() {
|
||||
const char* //
|
||||
bench_wuffs_gif_decode_1k_bw() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
wuffs_gif_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
@@ -2093,7 +2157,8 @@ const char* bench_wuffs_gif_decode_1k_bw() {
|
||||
2000);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_gif_decode_1k_color_full_init() {
|
||||
const char* //
|
||||
bench_wuffs_gif_decode_1k_color_full_init() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
wuffs_gif_decode, WUFFS_INITIALIZE__DEFAULT_OPTIONS,
|
||||
@@ -2103,7 +2168,8 @@ const char* bench_wuffs_gif_decode_1k_color_full_init() {
|
||||
1000);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_gif_decode_1k_color_part_init() {
|
||||
const char* //
|
||||
bench_wuffs_gif_decode_1k_color_part_init() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
wuffs_gif_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
@@ -2113,7 +2179,8 @@ const char* bench_wuffs_gif_decode_1k_color_part_init() {
|
||||
1000);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_gif_decode_10k_bgra() {
|
||||
const char* //
|
||||
bench_wuffs_gif_decode_10k_bgra() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
wuffs_gif_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
@@ -2122,7 +2189,8 @@ const char* bench_wuffs_gif_decode_10k_bgra() {
|
||||
100);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_gif_decode_10k_indexed() {
|
||||
const char* //
|
||||
bench_wuffs_gif_decode_10k_indexed() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
wuffs_gif_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
@@ -2132,7 +2200,8 @@ const char* bench_wuffs_gif_decode_10k_indexed() {
|
||||
100);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_gif_decode_20k() {
|
||||
const char* //
|
||||
bench_wuffs_gif_decode_20k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
wuffs_gif_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
@@ -2142,7 +2211,8 @@ const char* bench_wuffs_gif_decode_20k() {
|
||||
50);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_gif_decode_100k_artificial() {
|
||||
const char* //
|
||||
bench_wuffs_gif_decode_100k_artificial() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
wuffs_gif_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
@@ -2152,7 +2222,8 @@ const char* bench_wuffs_gif_decode_100k_artificial() {
|
||||
15);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_gif_decode_100k_realistic() {
|
||||
const char* //
|
||||
bench_wuffs_gif_decode_100k_realistic() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
wuffs_gif_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
@@ -2162,7 +2233,8 @@ const char* bench_wuffs_gif_decode_100k_realistic() {
|
||||
10);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_gif_decode_1000k_full_init() {
|
||||
const char* //
|
||||
bench_wuffs_gif_decode_1000k_full_init() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
wuffs_gif_decode, WUFFS_INITIALIZE__DEFAULT_OPTIONS,
|
||||
@@ -2172,7 +2244,8 @@ const char* bench_wuffs_gif_decode_1000k_full_init() {
|
||||
1);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_gif_decode_1000k_part_init() {
|
||||
const char* //
|
||||
bench_wuffs_gif_decode_1000k_part_init() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
wuffs_gif_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
@@ -2182,7 +2255,8 @@ const char* bench_wuffs_gif_decode_1000k_part_init() {
|
||||
1);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_gif_decode_anim_screencap() {
|
||||
const char* //
|
||||
bench_wuffs_gif_decode_anim_screencap() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
wuffs_gif_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
@@ -2196,7 +2270,8 @@ const char* bench_wuffs_gif_decode_anim_screencap() {
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
const char* bench_mimic_gif_decode_1k_bw() {
|
||||
const char* //
|
||||
bench_mimic_gif_decode_1k_bw() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
mimic_gif_decode, 0, "test/data/pjw-thumbnail.gif",
|
||||
@@ -2205,7 +2280,8 @@ const char* bench_mimic_gif_decode_1k_bw() {
|
||||
2000);
|
||||
}
|
||||
|
||||
const char* bench_mimic_gif_decode_1k_color() {
|
||||
const char* //
|
||||
bench_mimic_gif_decode_1k_color() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
mimic_gif_decode, 0, "test/data/hippopotamus.regular.gif",
|
||||
@@ -2214,7 +2290,8 @@ const char* bench_mimic_gif_decode_1k_color() {
|
||||
1000);
|
||||
}
|
||||
|
||||
const char* bench_mimic_gif_decode_10k_indexed() {
|
||||
const char* //
|
||||
bench_mimic_gif_decode_10k_indexed() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
mimic_gif_decode, 0, "test/data/hat.gif",
|
||||
@@ -2223,7 +2300,8 @@ const char* bench_mimic_gif_decode_10k_indexed() {
|
||||
100);
|
||||
}
|
||||
|
||||
const char* bench_mimic_gif_decode_20k() {
|
||||
const char* //
|
||||
bench_mimic_gif_decode_20k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
mimic_gif_decode, 0, "test/data/bricks-gray.gif",
|
||||
@@ -2232,7 +2310,8 @@ const char* bench_mimic_gif_decode_20k() {
|
||||
50);
|
||||
}
|
||||
|
||||
const char* bench_mimic_gif_decode_100k_artificial() {
|
||||
const char* //
|
||||
bench_mimic_gif_decode_100k_artificial() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
mimic_gif_decode, 0, "test/data/hibiscus.primitive.gif",
|
||||
@@ -2241,7 +2320,8 @@ const char* bench_mimic_gif_decode_100k_artificial() {
|
||||
15);
|
||||
}
|
||||
|
||||
const char* bench_mimic_gif_decode_100k_realistic() {
|
||||
const char* //
|
||||
bench_mimic_gif_decode_100k_realistic() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
mimic_gif_decode, 0, "test/data/hibiscus.regular.gif",
|
||||
@@ -2250,7 +2330,8 @@ const char* bench_mimic_gif_decode_100k_realistic() {
|
||||
10);
|
||||
}
|
||||
|
||||
const char* bench_mimic_gif_decode_1000k() {
|
||||
const char* //
|
||||
bench_mimic_gif_decode_1000k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
mimic_gif_decode, 0, "test/data/harvesters.gif",
|
||||
@@ -2259,7 +2340,8 @@ const char* bench_mimic_gif_decode_1000k() {
|
||||
1);
|
||||
}
|
||||
|
||||
const char* bench_mimic_gif_decode_anim_screencap() {
|
||||
const char* //
|
||||
bench_mimic_gif_decode_anim_screencap() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_gif_decode(
|
||||
mimic_gif_decode, 0, "test/data/gifplayer-muybridge.gif",
|
||||
@@ -2378,7 +2460,8 @@ proc benches[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/gif";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
}
|
||||
+36
-21
@@ -83,7 +83,8 @@ golden_test gzip_pi_gt = {
|
||||
|
||||
// ---------------- Gzip Tests
|
||||
|
||||
const char* test_wuffs_gzip_decode_interface() {
|
||||
const char* //
|
||||
test_wuffs_gzip_decode_interface() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_gzip__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -95,11 +96,12 @@ const char* test_wuffs_gzip_decode_interface() {
|
||||
"test/data/romeo.txt.gz", 0, SIZE_MAX, 942, 0x0A);
|
||||
}
|
||||
|
||||
const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
wuffs_gzip_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
wuffs_gzip__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_gzip__decoder__initialize(&dec, sizeof dec, WUFFS_VERSION,
|
||||
@@ -125,8 +127,8 @@ const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst,
|
||||
}
|
||||
}
|
||||
|
||||
const char* do_test_wuffs_gzip_checksum(bool ignore_checksum,
|
||||
uint32_t bad_checksum) {
|
||||
const char* //
|
||||
do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) {
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
});
|
||||
@@ -189,33 +191,39 @@ const char* do_test_wuffs_gzip_checksum(bool ignore_checksum,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_gzip_checksum_ignore() {
|
||||
const char* //
|
||||
test_wuffs_gzip_checksum_ignore() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gzip_checksum(true, 8 | 0);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gzip_checksum_verify_bad0() {
|
||||
const char* //
|
||||
test_wuffs_gzip_checksum_verify_bad0() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gzip_checksum(false, 8 | 0);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gzip_checksum_verify_bad7() {
|
||||
const char* //
|
||||
test_wuffs_gzip_checksum_verify_bad7() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gzip_checksum(false, 8 | 7);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gzip_checksum_verify_good() {
|
||||
const char* //
|
||||
test_wuffs_gzip_checksum_verify_good() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_gzip_checksum(false, 0);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gzip_decode_midsummer() {
|
||||
const char* //
|
||||
test_wuffs_gzip_decode_midsummer() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_gzip_decode, &gzip_midsummer_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_wuffs_gzip_decode_pi() {
|
||||
const char* //
|
||||
test_wuffs_gzip_decode_pi() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_gzip_decode, &gzip_pi_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
@@ -225,13 +233,15 @@ const char* test_wuffs_gzip_decode_pi() {
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
const char* test_mimic_gzip_decode_midsummer() {
|
||||
const char* //
|
||||
test_mimic_gzip_decode_midsummer() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_gzip_decode, &gzip_midsummer_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_mimic_gzip_decode_pi() {
|
||||
const char* //
|
||||
test_mimic_gzip_decode_pi() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_gzip_decode, &gzip_pi_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
@@ -241,14 +251,16 @@ const char* test_mimic_gzip_decode_pi() {
|
||||
|
||||
// ---------------- Gzip Benches
|
||||
|
||||
const char* bench_wuffs_gzip_decode_10k() {
|
||||
const char* //
|
||||
bench_wuffs_gzip_decode_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_gzip_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
tcounter_dst, &gzip_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_gzip_decode_100k() {
|
||||
const char* //
|
||||
bench_wuffs_gzip_decode_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_gzip_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
@@ -259,13 +271,15 @@ const char* bench_wuffs_gzip_decode_100k() {
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
const char* bench_mimic_gzip_decode_10k() {
|
||||
const char* //
|
||||
bench_mimic_gzip_decode_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_gzip_decode, 0, tcounter_dst,
|
||||
&gzip_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
}
|
||||
|
||||
const char* bench_mimic_gzip_decode_100k() {
|
||||
const char* //
|
||||
bench_mimic_gzip_decode_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_gzip_decode, 0, tcounter_dst, &gzip_pi_gt,
|
||||
UINT64_MAX, UINT64_MAX, 30);
|
||||
@@ -315,7 +329,8 @@ proc benches[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/gzip";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
}
|
||||
+24
-14
@@ -69,7 +69,8 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
|
||||
|
||||
// ---------------- String Conversions Tests
|
||||
|
||||
const char* test_strconv_parse_number_i64() {
|
||||
const char* //
|
||||
test_strconv_parse_number_i64() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
const int64_t fail = 0xDEADBEEF;
|
||||
@@ -117,7 +118,8 @@ const char* test_strconv_parse_number_i64() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_strconv_parse_number_u64() {
|
||||
const char* //
|
||||
test_strconv_parse_number_u64() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
const uint64_t fail = 0xDEADBEEF;
|
||||
@@ -216,7 +218,8 @@ golden_test json_nobel_prizes_gt = {
|
||||
|
||||
// ---------------- JSON Tests
|
||||
|
||||
const char* test_wuffs_json_decode_tokens() {
|
||||
const char* //
|
||||
test_wuffs_json_decode_tokens() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_json__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -253,11 +256,12 @@ const char* test_wuffs_json_decode_tokens() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* wuffs_json_decode(wuffs_base__token_buffer* tok,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
wuffs_json_decode(wuffs_base__token_buffer* tok,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
wuffs_json__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_json__decoder__initialize(&dec, sizeof dec, WUFFS_VERSION,
|
||||
@@ -284,7 +288,8 @@ const char* wuffs_json_decode(wuffs_base__token_buffer* tok,
|
||||
}
|
||||
}
|
||||
|
||||
const char* test_wuffs_json_decode_unicode4_escapes() {
|
||||
const char* //
|
||||
test_wuffs_json_decode_unicode4_escapes() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
const uint32_t fail = 0xDEADBEEF;
|
||||
@@ -403,28 +408,32 @@ const char* test_wuffs_json_decode_unicode4_escapes() {
|
||||
|
||||
// ---------------- JSON Benches
|
||||
|
||||
const char* bench_wuffs_json_decode_1k() {
|
||||
const char* //
|
||||
bench_wuffs_json_decode_1k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_token_decoder(
|
||||
wuffs_json_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
tcounter_src, &json_github_tags_gt, UINT64_MAX, UINT64_MAX, 10000);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_json_decode_21k_formatted() {
|
||||
const char* //
|
||||
bench_wuffs_json_decode_21k_formatted() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_token_decoder(
|
||||
wuffs_json_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
tcounter_src, &json_file_sizes_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_json_decode_26k_compact() {
|
||||
const char* //
|
||||
bench_wuffs_json_decode_26k_compact() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_token_decoder(
|
||||
wuffs_json_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
tcounter_src, &json_australian_abc_gt, UINT64_MAX, UINT64_MAX, 250);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_json_decode_217k_stringy() {
|
||||
const char* //
|
||||
bench_wuffs_json_decode_217k_stringy() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_token_decoder(
|
||||
wuffs_json_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
@@ -479,7 +488,8 @@ proc benches[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/json";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
}
|
||||
+39
-24
@@ -66,7 +66,8 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
|
||||
|
||||
// ---------------- LZW Tests
|
||||
|
||||
const char* test_wuffs_lzw_decode_interface() {
|
||||
const char* //
|
||||
test_wuffs_lzw_decode_interface() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_lzw__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -78,12 +79,13 @@ const char* test_wuffs_lzw_decode_interface() {
|
||||
"test/data/bricks-nodither.indexes.giflzw", 1, SIZE_MAX, 19200, 0x4F);
|
||||
}
|
||||
|
||||
const char* do_test_wuffs_lzw_decode(const char* src_filename,
|
||||
uint64_t src_size,
|
||||
const char* want_filename,
|
||||
uint64_t want_size,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
do_test_wuffs_lzw_decode(const char* src_filename,
|
||||
uint64_t src_size,
|
||||
const char* want_filename,
|
||||
uint64_t want_size,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
});
|
||||
@@ -168,42 +170,48 @@ const char* do_test_wuffs_lzw_decode(const char* src_filename,
|
||||
return check_io_buffers_equal("", &have, &want);
|
||||
}
|
||||
|
||||
const char* test_wuffs_lzw_decode_bricks_dither() {
|
||||
const char* //
|
||||
test_wuffs_lzw_decode_bricks_dither() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_lzw_decode("test/data/bricks-dither.indexes.giflzw",
|
||||
14923, "test/data/bricks-dither.indexes",
|
||||
19200, UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_wuffs_lzw_decode_bricks_nodither() {
|
||||
const char* //
|
||||
test_wuffs_lzw_decode_bricks_nodither() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_lzw_decode("test/data/bricks-nodither.indexes.giflzw",
|
||||
13382, "test/data/bricks-nodither.indexes",
|
||||
19200, UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_wuffs_lzw_decode_many_big_reads() {
|
||||
const char* //
|
||||
test_wuffs_lzw_decode_many_big_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_lzw_decode("test/data/bricks-gray.indexes.giflzw", 14731,
|
||||
"test/data/bricks-gray.indexes", 19200,
|
||||
UINT64_MAX, 4096);
|
||||
}
|
||||
|
||||
const char* test_wuffs_lzw_decode_many_small_writes_reads() {
|
||||
const char* //
|
||||
test_wuffs_lzw_decode_many_small_writes_reads() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_lzw_decode("test/data/bricks-gray.indexes.giflzw", 14731,
|
||||
"test/data/bricks-gray.indexes", 19200, 41,
|
||||
43);
|
||||
}
|
||||
|
||||
const char* test_wuffs_lzw_decode_pi() {
|
||||
const char* //
|
||||
test_wuffs_lzw_decode_pi() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_lzw_decode("test/data/pi.txt.giflzw", 50550,
|
||||
"test/data/pi.txt", 100003, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_wuffs_lzw_decode_output_bad() {
|
||||
const char* //
|
||||
test_wuffs_lzw_decode_output_bad() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
@@ -249,7 +257,8 @@ const char* test_wuffs_lzw_decode_output_bad() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_lzw_decode_output_empty() {
|
||||
const char* //
|
||||
test_wuffs_lzw_decode_output_empty() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
@@ -288,9 +297,10 @@ const char* test_wuffs_lzw_decode_output_empty() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* do_test_wuffs_lzw_decode_width(uint32_t width,
|
||||
wuffs_base__io_buffer src,
|
||||
wuffs_base__io_buffer want) {
|
||||
const char* //
|
||||
do_test_wuffs_lzw_decode_width(uint32_t width,
|
||||
wuffs_base__io_buffer src,
|
||||
wuffs_base__io_buffer want) {
|
||||
wuffs_lzw__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_lzw__decoder__initialize(
|
||||
@@ -312,7 +322,8 @@ const char* do_test_wuffs_lzw_decode_width(uint32_t width,
|
||||
// two bits but the first non-Clear code after a Clear code has only one bit,
|
||||
// so it must be the literal 0x00. Nonetheless, the giflib C library accepts a
|
||||
// zero literal width (it only rejects literal widths above 8), so we do too.
|
||||
const char* test_wuffs_lzw_decode_width_0() {
|
||||
const char* //
|
||||
test_wuffs_lzw_decode_width_0() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
// 0b...._...._...._...1 0x001 Clear code.
|
||||
@@ -343,7 +354,8 @@ const char* test_wuffs_lzw_decode_width_0() {
|
||||
return do_test_wuffs_lzw_decode_width(0, src, want);
|
||||
}
|
||||
|
||||
const char* test_wuffs_lzw_decode_width_1() {
|
||||
const char* //
|
||||
test_wuffs_lzw_decode_width_1() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
// 0b...._...._...._..10 0x010 Clear code.
|
||||
@@ -372,8 +384,8 @@ const char* test_wuffs_lzw_decode_width_1() {
|
||||
|
||||
// ---------------- LZW Benches
|
||||
|
||||
const char* do_bench_wuffs_lzw_decode(const char* filename,
|
||||
uint64_t iters_unscaled) {
|
||||
const char* //
|
||||
do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) {
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
});
|
||||
@@ -411,12 +423,14 @@ const char* do_bench_wuffs_lzw_decode(const char* filename,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* bench_wuffs_lzw_decode_20k() {
|
||||
const char* //
|
||||
bench_wuffs_lzw_decode_20k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_wuffs_lzw_decode("test/data/bricks-gray.indexes.giflzw", 50);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_lzw_decode_100k() {
|
||||
const char* //
|
||||
bench_wuffs_lzw_decode_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_wuffs_lzw_decode("test/data/pi.txt.giflzw", 10);
|
||||
}
|
||||
@@ -449,7 +463,8 @@ proc benches[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/lzw";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
}
|
||||
+10
-5
@@ -69,7 +69,8 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
|
||||
|
||||
// ---------------- WBMP Tests
|
||||
|
||||
const char* test_wuffs_wbmp_decode_interface() {
|
||||
const char* //
|
||||
test_wuffs_wbmp_decode_interface() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_wbmp__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -81,7 +82,8 @@ const char* test_wuffs_wbmp_decode_interface() {
|
||||
"test/data/muybridge-frame-000.wbmp", 0, SIZE_MAX, 30, 20, 0xFFFFFFFF);
|
||||
}
|
||||
|
||||
const char* test_wuffs_wbmp_decode_frame_config() {
|
||||
const char* //
|
||||
test_wuffs_wbmp_decode_frame_config() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_wbmp__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -110,7 +112,8 @@ const char* test_wuffs_wbmp_decode_frame_config() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_wbmp_decode_image_config() {
|
||||
const char* //
|
||||
test_wuffs_wbmp_decode_image_config() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_wbmp__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -129,7 +132,8 @@ const char* test_wuffs_wbmp_decode_image_config() {
|
||||
uint32_t have_width = wuffs_base__pixel_config__width(&ic.pixcfg);
|
||||
uint32_t want_width = 160;
|
||||
if (have_width != want_width) {
|
||||
RETURN_FAIL("width: have %" PRIu32 ", want %" PRIu32, have_width, want_width);
|
||||
RETURN_FAIL("width: have %" PRIu32 ", want %" PRIu32, have_width,
|
||||
want_width);
|
||||
}
|
||||
uint32_t have_height = wuffs_base__pixel_config__height(&ic.pixcfg);
|
||||
uint32_t want_height = 120;
|
||||
@@ -192,7 +196,8 @@ proc benches[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/wbmp";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
}
|
||||
+40
-23
@@ -94,7 +94,8 @@ const size_t zlib_sheep_want_len = 11;
|
||||
|
||||
// ---------------- Zlib Tests
|
||||
|
||||
const char* test_wuffs_zlib_decode_interface() {
|
||||
const char* //
|
||||
test_wuffs_zlib_decode_interface() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_zlib__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -106,11 +107,12 @@ const char* test_wuffs_zlib_decode_interface() {
|
||||
"test/data/romeo.txt.zlib", 0, SIZE_MAX, 942, 0x0A);
|
||||
}
|
||||
|
||||
const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
wuffs_zlib_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
wuffs_zlib__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_zlib__decoder__initialize(&dec, sizeof dec, WUFFS_VERSION,
|
||||
@@ -136,8 +138,8 @@ const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst,
|
||||
}
|
||||
}
|
||||
|
||||
const char* do_test_wuffs_zlib_checksum(bool ignore_checksum,
|
||||
uint32_t bad_checksum) {
|
||||
const char* //
|
||||
do_test_wuffs_zlib_checksum(bool ignore_checksum, uint32_t bad_checksum) {
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
});
|
||||
@@ -200,39 +202,46 @@ const char* do_test_wuffs_zlib_checksum(bool ignore_checksum,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* test_wuffs_zlib_checksum_ignore() {
|
||||
const char* //
|
||||
test_wuffs_zlib_checksum_ignore() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_zlib_checksum(true, 4 | 0);
|
||||
}
|
||||
|
||||
const char* test_wuffs_zlib_checksum_verify_bad0() {
|
||||
const char* //
|
||||
test_wuffs_zlib_checksum_verify_bad0() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_zlib_checksum(false, 4 | 0);
|
||||
}
|
||||
|
||||
const char* test_wuffs_zlib_checksum_verify_bad3() {
|
||||
const char* //
|
||||
test_wuffs_zlib_checksum_verify_bad3() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_zlib_checksum(false, 4 | 3);
|
||||
}
|
||||
|
||||
const char* test_wuffs_zlib_checksum_verify_good() {
|
||||
const char* //
|
||||
test_wuffs_zlib_checksum_verify_good() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_wuffs_zlib_checksum(false, 0);
|
||||
}
|
||||
|
||||
const char* test_wuffs_zlib_decode_midsummer() {
|
||||
const char* //
|
||||
test_wuffs_zlib_decode_midsummer() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_zlib_decode, &zlib_midsummer_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_wuffs_zlib_decode_pi() {
|
||||
const char* //
|
||||
test_wuffs_zlib_decode_pi() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_zlib_decode, &zlib_pi_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_wuffs_zlib_decode_sheep() {
|
||||
const char* //
|
||||
test_wuffs_zlib_decode_sheep() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
@@ -282,19 +291,22 @@ const char* test_wuffs_zlib_decode_sheep() {
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
const char* test_mimic_zlib_decode_midsummer() {
|
||||
const char* //
|
||||
test_mimic_zlib_decode_midsummer() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_zlib_decode, &zlib_midsummer_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_mimic_zlib_decode_pi() {
|
||||
const char* //
|
||||
test_mimic_zlib_decode_pi() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_zlib_decode, &zlib_pi_gt, UINT64_MAX,
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* test_mimic_zlib_decode_sheep() {
|
||||
const char* //
|
||||
test_mimic_zlib_decode_sheep() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = global_have_slice,
|
||||
@@ -318,14 +330,16 @@ const char* test_mimic_zlib_decode_sheep() {
|
||||
|
||||
// ---------------- Zlib Benches
|
||||
|
||||
const char* bench_wuffs_zlib_decode_10k() {
|
||||
const char* //
|
||||
bench_wuffs_zlib_decode_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_zlib_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
tcounter_dst, &zlib_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
}
|
||||
|
||||
const char* bench_wuffs_zlib_decode_100k() {
|
||||
const char* //
|
||||
bench_wuffs_zlib_decode_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_zlib_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
@@ -336,13 +350,15 @@ const char* bench_wuffs_zlib_decode_100k() {
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
const char* bench_mimic_zlib_decode_10k() {
|
||||
const char* //
|
||||
bench_mimic_zlib_decode_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_zlib_decode, 0, tcounter_dst,
|
||||
&zlib_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
|
||||
}
|
||||
|
||||
const char* bench_mimic_zlib_decode_100k() {
|
||||
const char* //
|
||||
bench_mimic_zlib_decode_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(mimic_zlib_decode, 0, tcounter_dst, &zlib_pi_gt,
|
||||
UINT64_MAX, UINT64_MAX, 30);
|
||||
@@ -391,7 +407,8 @@ proc benches[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
proc_package_name = "std/zlib";
|
||||
return test_main(argc, argv, tests, benches);
|
||||
}
|
||||
+117
-103
@@ -117,7 +117,8 @@ bool in_focus = false;
|
||||
return NULL; \
|
||||
}
|
||||
|
||||
bool check_focus() {
|
||||
bool //
|
||||
check_focus() {
|
||||
const char* p = focus;
|
||||
if (!*p) {
|
||||
return true;
|
||||
@@ -215,11 +216,13 @@ typedef struct {
|
||||
bool bench_warm_up;
|
||||
struct timeval bench_start_tv;
|
||||
|
||||
void bench_start() {
|
||||
void //
|
||||
bench_start() {
|
||||
gettimeofday(&bench_start_tv, NULL);
|
||||
}
|
||||
|
||||
void bench_finish(uint64_t iters, uint64_t n_bytes) {
|
||||
void //
|
||||
bench_finish(uint64_t iters, uint64_t n_bytes) {
|
||||
struct timeval bench_finish_tv;
|
||||
gettimeofday(&bench_finish_tv, NULL);
|
||||
int64_t micros =
|
||||
@@ -252,7 +255,8 @@ void bench_finish(uint64_t iters, uint64_t n_bytes) {
|
||||
fflush(stdout);
|
||||
}
|
||||
|
||||
const char* chdir_to_the_wuffs_root_directory() {
|
||||
const char* //
|
||||
chdir_to_the_wuffs_root_directory() {
|
||||
// Chdir to the Wuffs root directory, assuming that we're starting from
|
||||
// somewhere in the Wuffs repository, so we can find the root directory by
|
||||
// running chdir("..") a number of times.
|
||||
@@ -279,7 +283,8 @@ const char* chdir_to_the_wuffs_root_directory() {
|
||||
|
||||
typedef const char* (*proc)();
|
||||
|
||||
int test_main(int argc, char** argv, proc* tests, proc* benches) {
|
||||
int //
|
||||
test_main(int argc, char** argv, proc* tests, proc* benches) {
|
||||
wuffs_testlib__initialize_global_xxx_slices();
|
||||
const char* status = chdir_to_the_wuffs_root_directory();
|
||||
if (status) {
|
||||
@@ -393,7 +398,8 @@ int test_main(int argc, char** argv, proc* tests, proc* benches) {
|
||||
// WUFFS_INCLUDE_GUARD is where wuffs_base__foo_bar are defined.
|
||||
#ifdef WUFFS_INCLUDE_GUARD
|
||||
|
||||
wuffs_base__io_buffer make_io_buffer_from_string(const char* ptr, size_t len) {
|
||||
wuffs_base__io_buffer //
|
||||
make_io_buffer_from_string(const char* ptr, size_t len) {
|
||||
return ((wuffs_base__io_buffer){
|
||||
.data = ((wuffs_base__slice_u8){
|
||||
.ptr = ((uint8_t*)(ptr)),
|
||||
@@ -406,10 +412,8 @@ wuffs_base__io_buffer make_io_buffer_from_string(const char* ptr, size_t len) {
|
||||
});
|
||||
}
|
||||
|
||||
wuffs_base__rect_ie_u32 make_rect_ie_u32(uint32_t x0,
|
||||
uint32_t y0,
|
||||
uint32_t x1,
|
||||
uint32_t y1) {
|
||||
wuffs_base__rect_ie_u32 //
|
||||
make_rect_ie_u32(uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1) {
|
||||
wuffs_base__rect_ie_u32 ret;
|
||||
ret.min_incl_x = x0;
|
||||
ret.min_incl_y = y0;
|
||||
@@ -418,8 +422,8 @@ wuffs_base__rect_ie_u32 make_rect_ie_u32(uint32_t x0,
|
||||
return ret;
|
||||
}
|
||||
|
||||
wuffs_base__io_buffer make_limited_reader(wuffs_base__io_buffer b,
|
||||
uint64_t limit) {
|
||||
wuffs_base__io_buffer //
|
||||
make_limited_reader(wuffs_base__io_buffer b, uint64_t limit) {
|
||||
uint64_t n = b.meta.wi - b.meta.ri;
|
||||
bool closed = b.meta.closed;
|
||||
if (n > limit) {
|
||||
@@ -437,8 +441,8 @@ wuffs_base__io_buffer make_limited_reader(wuffs_base__io_buffer b,
|
||||
return ret;
|
||||
}
|
||||
|
||||
wuffs_base__io_buffer make_limited_writer(wuffs_base__io_buffer b,
|
||||
uint64_t limit) {
|
||||
wuffs_base__io_buffer //
|
||||
make_limited_writer(wuffs_base__io_buffer b, uint64_t limit) {
|
||||
uint64_t n = b.data.len - b.meta.wi;
|
||||
if (n > limit) {
|
||||
n = limit;
|
||||
@@ -454,8 +458,8 @@ wuffs_base__io_buffer make_limited_writer(wuffs_base__io_buffer b,
|
||||
return ret;
|
||||
}
|
||||
|
||||
wuffs_base__token_buffer make_limited_token_writer(wuffs_base__token_buffer b,
|
||||
uint64_t limit) {
|
||||
wuffs_base__token_buffer //
|
||||
make_limited_token_writer(wuffs_base__token_buffer b, uint64_t limit) {
|
||||
uint64_t n = b.data.len - b.meta.wi;
|
||||
if (n > limit) {
|
||||
n = limit;
|
||||
@@ -472,9 +476,10 @@ wuffs_base__token_buffer make_limited_token_writer(wuffs_base__token_buffer b,
|
||||
}
|
||||
|
||||
// TODO: we shouldn't need to pass the rect. Instead, pass a subset pixbuf.
|
||||
const char* copy_to_io_buffer_from_pixel_buffer(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__pixel_buffer* src,
|
||||
wuffs_base__rect_ie_u32 r) {
|
||||
const char* //
|
||||
copy_to_io_buffer_from_pixel_buffer(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__pixel_buffer* src,
|
||||
wuffs_base__rect_ie_u32 r) {
|
||||
if (!src) {
|
||||
return "copy_to_io_buffer_from_pixel_buffer: NULL src";
|
||||
}
|
||||
@@ -521,7 +526,8 @@ const char* copy_to_io_buffer_from_pixel_buffer(wuffs_base__io_buffer* dst,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* read_file(wuffs_base__io_buffer* dst, const char* path) {
|
||||
const char* //
|
||||
read_file(wuffs_base__io_buffer* dst, const char* path) {
|
||||
if (!dst || !path) {
|
||||
RETURN_FAIL("read_file: NULL argument");
|
||||
}
|
||||
@@ -573,10 +579,11 @@ const char* read_file(wuffs_base__io_buffer* dst, const char* path) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* read_file_fragment(wuffs_base__io_buffer* dst,
|
||||
const char* path,
|
||||
size_t ri_min,
|
||||
size_t wi_max) {
|
||||
const char* //
|
||||
read_file_fragment(wuffs_base__io_buffer* dst,
|
||||
const char* path,
|
||||
size_t ri_min,
|
||||
size_t wi_max) {
|
||||
CHECK_STRING(read_file(dst, path));
|
||||
if (dst->meta.ri < ri_min) {
|
||||
dst->meta.ri = ri_min;
|
||||
@@ -590,7 +597,8 @@ const char* read_file_fragment(wuffs_base__io_buffer* dst,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
char* hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) {
|
||||
char* //
|
||||
hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) {
|
||||
if (!msg || !buf) {
|
||||
RETURN_FAIL("hex_dump: NULL argument");
|
||||
}
|
||||
@@ -639,9 +647,10 @@ char* hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) {
|
||||
return msg;
|
||||
}
|
||||
|
||||
const char* check_io_buffers_equal(const char* prefix,
|
||||
wuffs_base__io_buffer* have,
|
||||
wuffs_base__io_buffer* want) {
|
||||
const char* //
|
||||
check_io_buffers_equal(const char* prefix,
|
||||
wuffs_base__io_buffer* have,
|
||||
wuffs_base__io_buffer* want) {
|
||||
if (!have || !want) {
|
||||
RETURN_FAIL("%sio_buffers_equal: NULL argument", prefix);
|
||||
}
|
||||
@@ -679,18 +688,19 @@ typedef enum {
|
||||
tcounter_src = 2,
|
||||
} throughput_counter;
|
||||
|
||||
const char* proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
|
||||
wuffs_base__io_buffer*,
|
||||
uint32_t,
|
||||
uint64_t,
|
||||
uint64_t),
|
||||
uint32_t wuffs_initialize_flags,
|
||||
throughput_counter tcounter,
|
||||
golden_test* gt,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit,
|
||||
uint64_t iters,
|
||||
bool bench) {
|
||||
const char* //
|
||||
proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
|
||||
wuffs_base__io_buffer*,
|
||||
uint32_t,
|
||||
uint64_t,
|
||||
uint64_t),
|
||||
uint32_t wuffs_initialize_flags,
|
||||
throughput_counter tcounter,
|
||||
golden_test* gt,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit,
|
||||
uint64_t iters,
|
||||
bool bench) {
|
||||
if (!codec_func) {
|
||||
RETURN_FAIL("NULL codec_func");
|
||||
}
|
||||
@@ -767,19 +777,19 @@ const char* proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
|
||||
return check_io_buffers_equal("", &have, &want);
|
||||
}
|
||||
|
||||
const char* proc_token_decoder(
|
||||
const char* (*codec_func)(wuffs_base__token_buffer*,
|
||||
wuffs_base__io_buffer*,
|
||||
uint32_t,
|
||||
uint64_t,
|
||||
uint64_t),
|
||||
uint32_t wuffs_initialize_flags,
|
||||
throughput_counter tcounter,
|
||||
golden_test* gt,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit,
|
||||
uint64_t iters,
|
||||
bool bench) {
|
||||
const char* //
|
||||
proc_token_decoder(const char* (*codec_func)(wuffs_base__token_buffer*,
|
||||
wuffs_base__io_buffer*,
|
||||
uint32_t,
|
||||
uint64_t,
|
||||
uint64_t),
|
||||
uint32_t wuffs_initialize_flags,
|
||||
throughput_counter tcounter,
|
||||
golden_test* gt,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit,
|
||||
uint64_t iters,
|
||||
bool bench) {
|
||||
if (!codec_func) {
|
||||
RETURN_FAIL("NULL codec_func");
|
||||
}
|
||||
@@ -843,46 +853,47 @@ const char* proc_token_decoder(
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* do_bench_io_buffers(
|
||||
const char* (*codec_func)(wuffs_base__io_buffer*,
|
||||
wuffs_base__io_buffer*,
|
||||
uint32_t,
|
||||
uint64_t,
|
||||
uint64_t),
|
||||
uint32_t wuffs_initialize_flags,
|
||||
throughput_counter tcounter,
|
||||
golden_test* gt,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit,
|
||||
uint64_t iters_unscaled) {
|
||||
const char* //
|
||||
do_bench_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
|
||||
wuffs_base__io_buffer*,
|
||||
uint32_t,
|
||||
uint64_t,
|
||||
uint64_t),
|
||||
uint32_t wuffs_initialize_flags,
|
||||
throughput_counter tcounter,
|
||||
golden_test* gt,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit,
|
||||
uint64_t iters_unscaled) {
|
||||
return proc_io_buffers(codec_func, wuffs_initialize_flags, tcounter, gt,
|
||||
wlimit, rlimit, iters_unscaled * iterscale, true);
|
||||
}
|
||||
|
||||
const char* do_bench_token_decoder(
|
||||
const char* (*codec_func)(wuffs_base__token_buffer*,
|
||||
wuffs_base__io_buffer*,
|
||||
uint32_t,
|
||||
uint64_t,
|
||||
uint64_t),
|
||||
uint32_t wuffs_initialize_flags,
|
||||
throughput_counter tcounter,
|
||||
golden_test* gt,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit,
|
||||
uint64_t iters_unscaled) {
|
||||
const char* //
|
||||
do_bench_token_decoder(const char* (*codec_func)(wuffs_base__token_buffer*,
|
||||
wuffs_base__io_buffer*,
|
||||
uint32_t,
|
||||
uint64_t,
|
||||
uint64_t),
|
||||
uint32_t wuffs_initialize_flags,
|
||||
throughput_counter tcounter,
|
||||
golden_test* gt,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit,
|
||||
uint64_t iters_unscaled) {
|
||||
return proc_token_decoder(codec_func, wuffs_initialize_flags, tcounter, gt,
|
||||
wlimit, rlimit, iters_unscaled * iterscale, true);
|
||||
}
|
||||
|
||||
const char* do_test_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
|
||||
wuffs_base__io_buffer*,
|
||||
uint32_t,
|
||||
uint64_t,
|
||||
uint64_t),
|
||||
golden_test* gt,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
const char* //
|
||||
do_test_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
|
||||
wuffs_base__io_buffer*,
|
||||
uint32_t,
|
||||
uint64_t,
|
||||
uint64_t),
|
||||
golden_test* gt,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
return proc_io_buffers(codec_func,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
tcounter_neither, gt, wlimit, rlimit, 1, false);
|
||||
@@ -890,11 +901,12 @@ const char* do_test_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
|
||||
|
||||
// --------
|
||||
|
||||
const char* do_test__wuffs_base__hasher_u32(wuffs_base__hasher_u32* b,
|
||||
const char* src_filename,
|
||||
size_t src_ri,
|
||||
size_t src_wi,
|
||||
uint32_t want) {
|
||||
const char* //
|
||||
do_test__wuffs_base__hasher_u32(wuffs_base__hasher_u32* b,
|
||||
const char* src_filename,
|
||||
size_t src_ri,
|
||||
size_t src_wi,
|
||||
uint32_t want) {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
});
|
||||
@@ -910,12 +922,12 @@ const char* do_test__wuffs_base__hasher_u32(wuffs_base__hasher_u32* b,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* do_test__wuffs_base__image_config_decoder(
|
||||
wuffs_base__image_decoder* b,
|
||||
const char* src_filename,
|
||||
size_t src_ri,
|
||||
size_t src_wi,
|
||||
uint64_t want_num_frames) {
|
||||
const char* //
|
||||
do_test__wuffs_base__image_config_decoder(wuffs_base__image_decoder* b,
|
||||
const char* src_filename,
|
||||
size_t src_ri,
|
||||
size_t src_wi,
|
||||
uint64_t want_num_frames) {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = global_src_slice,
|
||||
});
|
||||
@@ -939,7 +951,8 @@ const char* do_test__wuffs_base__image_config_decoder(
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* do_test__wuffs_base__image_decoder(
|
||||
const char* //
|
||||
do_test__wuffs_base__image_decoder(
|
||||
wuffs_base__image_decoder* b,
|
||||
const char* src_filename,
|
||||
size_t src_ri,
|
||||
@@ -1007,12 +1020,13 @@ const char* do_test__wuffs_base__image_decoder(
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* do_test__wuffs_base__io_transformer(wuffs_base__io_transformer* b,
|
||||
const char* src_filename,
|
||||
size_t src_ri,
|
||||
size_t src_wi,
|
||||
size_t want_wi,
|
||||
uint8_t want_final_byte) {
|
||||
const char* //
|
||||
do_test__wuffs_base__io_transformer(wuffs_base__io_transformer* b,
|
||||
const char* src_filename,
|
||||
size_t src_ri,
|
||||
size_t src_wi,
|
||||
size_t want_wi,
|
||||
uint8_t want_final_byte) {
|
||||
if (want_wi > BUFFER_SIZE) {
|
||||
return "want_wi is too large";
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user