diff --git a/example/crc32/crc32.cc b/example/crc32/crc32.cc index 09d2512f..b32b7b22 100644 --- a/example/crc32/crc32.cc +++ b/example/crc32/crc32.cc @@ -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()) { diff --git a/example/gifplayer/gifplayer.c b/example/gifplayer/gifplayer.c index b8ef36e9..82ebb67e 100644 --- a/example/gifplayer/gifplayer.c +++ b/example/gifplayer/gifplayer.c @@ -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")) { diff --git a/example/imageviewer/imageviewer.c b/example/imageviewer/imageviewer.c index 8cc25c0f..f1634a0e 100644 --- a/example/imageviewer/imageviewer.c +++ b/example/imageviewer/imageviewer.c @@ -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; } diff --git a/example/jsonptr/jsonptr.cc b/example/jsonptr/jsonptr.cc index 783faa24..bc0fd8f3 100644 --- a/example/jsonptr/jsonptr.cc +++ b/example/jsonptr/jsonptr.cc @@ -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(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); diff --git a/example/library/library.c b/example/library/library.c index 4cc426c9..62b29683 100644 --- a/example/library/library.c +++ b/example/library/library.c @@ -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); diff --git a/example/zcat/zcat.c b/example/zcat/zcat.c index 7652c48c..4d7398b7 100644 --- a/example/zcat/zcat.c +++ b/example/zcat/zcat.c @@ -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 diff --git a/fuzz/c/fuzzlib/fuzzlib.c b/fuzz/c/fuzzlib/fuzzlib.c index 74e6baa7..0ce866c3 100644 --- a/fuzz/c/fuzzlib/fuzzlib.c +++ b/fuzz/c/fuzzlib/fuzzlib.c @@ -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; diff --git a/fuzz/c/std/gif_fuzzer.c b/fuzz/c/std/gif_fuzzer.c index d9460c69..af67e920 100644 --- a/fuzz/c/std/gif_fuzzer.c +++ b/fuzz/c/std/gif_fuzzer.c @@ -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){}); diff --git a/fuzz/c/std/zlib_fuzzer.c b/fuzz/c/std/zlib_fuzzer.c index 785aa14f..ff673501 100644 --- a/fuzz/c/std/zlib_fuzzer.c +++ b/fuzz/c/std/zlib_fuzzer.c @@ -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, diff --git a/script/adler32-standalone.c b/script/adler32-standalone.c index 29de1c07..786cc552 100644 --- a/script/adler32-standalone.c +++ b/script/adler32-standalone.c @@ -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++) { diff --git a/script/bench-c-deflate-fragmentation.c b/script/bench-c-deflate-fragmentation.c index 429fa7cd..5dc14c00 100644 --- a/script/bench-c-deflate-fragmentation.c +++ b/script/bench-c-deflate-fragmentation.c @@ -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); diff --git a/script/mmap-ring-buffer.c b/script/mmap-ring-buffer.c index d80538bc..2a258258 100644 --- a/script/mmap-ring-buffer.c +++ b/script/mmap-ring-buffer.c @@ -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"); diff --git a/script/wuffs-deflate-decoder-decode-huffman.c b/script/wuffs-deflate-decoder-decode-huffman.c index 2824ad36..39adb6a8 100644 --- a/script/wuffs-deflate-decoder-decode-huffman.c +++ b/script/wuffs-deflate-decoder-decode-huffman.c @@ -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); diff --git a/test/c/mimiclib/deflate-gzip-zlib.c b/test/c/mimiclib/deflate-gzip-zlib.c index 13df3fc1..21befbe1 100644 --- a/test/c/mimiclib/deflate-gzip-zlib.c +++ b/test/c/mimiclib/deflate-gzip-zlib.c @@ -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); } diff --git a/test/c/mimiclib/gif.c b/test/c/mimiclib/gif.c index 3e190fdc..ca3e699e 100644 --- a/test/c/mimiclib/gif.c +++ b/test/c/mimiclib/gif.c @@ -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 diff --git a/test/c/std/adler32.c b/test/c/std/adler32.c index f761964a..0c5a0442 100644 --- a/test/c/std/adler32.c +++ b/test/c/std/adler32.c @@ -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); } diff --git a/test/c/std/bmp.c b/test/c/std/bmp.c index 0cfc5c91..6f90c258 100644 --- a/test/c/std/bmp.c +++ b/test/c/std/bmp.c @@ -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); } diff --git a/test/c/std/crc32.c b/test/c/std/crc32.c index 4f422acd..9a210c4e 100644 --- a/test/c/std/crc32.c +++ b/test/c/std/crc32.c @@ -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); } diff --git a/test/c/std/deflate.c b/test/c/std/deflate.c index b2c30edf..9883ba88 100644 --- a/test/c/std/deflate.c +++ b/test/c/std/deflate.c @@ -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); } diff --git a/test/c/std/gif.c b/test/c/std/gif.c index 7140698c..e70be1fe 100644 --- a/test/c/std/gif.c +++ b/test/c/std/gif.c @@ -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); } diff --git a/test/c/std/gzip.c b/test/c/std/gzip.c index 2d02ff9c..5be741f9 100644 --- a/test/c/std/gzip.c +++ b/test/c/std/gzip.c @@ -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); } diff --git a/test/c/std/json.c b/test/c/std/json.c index b54724ed..ebc7153f 100644 --- a/test/c/std/json.c +++ b/test/c/std/json.c @@ -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); } diff --git a/test/c/std/lzw.c b/test/c/std/lzw.c index 72ca6b7f..129ddb6c 100644 --- a/test/c/std/lzw.c +++ b/test/c/std/lzw.c @@ -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); } diff --git a/test/c/std/wbmp.c b/test/c/std/wbmp.c index 1c639d64..f7b718e0 100644 --- a/test/c/std/wbmp.c +++ b/test/c/std/wbmp.c @@ -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); } diff --git a/test/c/std/zlib.c b/test/c/std/zlib.c index a9e61f0e..1721f4dc 100644 --- a/test/c/std/zlib.c +++ b/test/c/std/zlib.c @@ -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); } diff --git a/test/c/testlib/testlib.c b/test/c/testlib/testlib.c index c27b3561..e7dc6e4c 100644 --- a/test/c/testlib/testlib.c +++ b/test/c/testlib/testlib.c @@ -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"; }