diff --git a/test/c/mimiclib/deflate-gzip-zlib.c b/test/c/mimiclib/deflate-gzip-zlib.c
index 9b9c0c3..4c3a740 100644
--- a/test/c/mimiclib/deflate-gzip-zlib.c
+++ b/test/c/mimiclib/deflate-gzip-zlib.c
@@ -42,7 +42,7 @@
                                       uint64_t wlimit,
                                       uint64_t rlimit,
                                       bool deflate_instead_of_zlib) {
-  if (wlimit || rlimit) {
+  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.
     return "unsupported I/O limit";
@@ -99,7 +99,7 @@
     size_t len = src->meta.wi - src->meta.ri;
     if (len > 0x7FFFFFFF) {
       return "src length is too large";
-    } else if ((len > rlimit) && (rlimit > 0)) {
+    } else if (len > rlimit) {
       len = rlimit;
     }
     global_mimiclib_deflate_unused_u32 =
@@ -120,7 +120,7 @@
     size_t len = src->meta.wi - src->meta.ri;
     if (len > 0x7FFFFFFF) {
       return "src length is too large";
-    } else if ((len > rlimit) && (rlimit > 0)) {
+    } else if (len > rlimit) {
       len = rlimit;
     }
     global_mimiclib_deflate_unused_u32 =
@@ -178,14 +178,14 @@
   while (true) {
     z.next_in = src->data.ptr + src->meta.ri;
     z.avail_in = src->meta.wi - src->meta.ri;
-    if ((z.avail_in > rlimit) && (rlimit > 0)) {
+    if (z.avail_in > rlimit) {
       z.avail_in = rlimit;
     }
     uInt initial_avail_in = z.avail_in;
 
     z.next_out = dst->data.ptr + dst->meta.wi;
     z.avail_out = dst->data.len - dst->meta.wi;
-    if ((z.avail_out > wlimit) && (wlimit > 0)) {
+    if (z.avail_out > wlimit) {
       z.avail_out = wlimit;
     }
     uInt initial_avail_out = z.avail_out;
diff --git a/test/c/std/adler32.c b/test/c/std/adler32.c
index 9e509a9..b48a707 100644
--- a/test/c/std/adler32.c
+++ b/test/c/std/adler32.c
@@ -253,7 +253,7 @@
   return do_bench_io_buffers(
       wuffs_bench_adler32,
       WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tc_src,
-      &adler32_midsummer_gt, 0, 0, 1500);
+      &adler32_midsummer_gt, UINT64_MAX, UINT64_MAX, 1500);
 }
 
 const char* bench_wuffs_adler32_100k() {
@@ -261,7 +261,7 @@
   return do_bench_io_buffers(
       wuffs_bench_adler32,
       WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tc_src,
-      &adler32_pi_gt, 0, 0, 150);
+      &adler32_pi_gt, UINT64_MAX, UINT64_MAX, 150);
 }
 
   // ---------------- Mimic Benches
@@ -271,13 +271,14 @@
 const char* bench_mimic_adler32_10k() {
   CHECK_FOCUS(__func__);
   return do_bench_io_buffers(mimic_bench_adler32, 0, tc_src,
-                             &adler32_midsummer_gt, 0, 0, 1500);
+                             &adler32_midsummer_gt, UINT64_MAX, UINT64_MAX,
+                             1500);
 }
 
 const char* bench_mimic_adler32_100k() {
   CHECK_FOCUS(__func__);
-  return do_bench_io_buffers(mimic_bench_adler32, 0, tc_src, &adler32_pi_gt, 0,
-                             0, 150);
+  return do_bench_io_buffers(mimic_bench_adler32, 0, tc_src, &adler32_pi_gt,
+                             UINT64_MAX, UINT64_MAX, 150);
 }
 
 #endif  // WUFFS_MIMIC
diff --git a/test/c/std/crc32.c b/test/c/std/crc32.c
index b2c395d..33322c0 100644
--- a/test/c/std/crc32.c
+++ b/test/c/std/crc32.c
@@ -288,7 +288,7 @@
   return do_bench_io_buffers(
       wuffs_bench_crc32_ieee,
       WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tc_src,
-      &crc32_midsummer_gt, 0, 0, 1500);
+      &crc32_midsummer_gt, UINT64_MAX, UINT64_MAX, 1500);
 }
 
 const char* bench_wuffs_crc32_ieee_100k() {
@@ -296,7 +296,7 @@
   return do_bench_io_buffers(
       wuffs_bench_crc32_ieee,
       WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tc_src,
-      &crc32_pi_gt, 0, 0, 150);
+      &crc32_pi_gt, UINT64_MAX, UINT64_MAX, 150);
 }
 
   // ---------------- Mimic Benches
@@ -306,13 +306,13 @@
 const char* bench_mimic_crc32_ieee_10k() {
   CHECK_FOCUS(__func__);
   return do_bench_io_buffers(mimic_bench_crc32_ieee, 0, tc_src,
-                             &crc32_midsummer_gt, 0, 0, 1500);
+                             &crc32_midsummer_gt, UINT64_MAX, UINT64_MAX, 1500);
 }
 
 const char* bench_mimic_crc32_ieee_100k() {
   CHECK_FOCUS(__func__);
-  return do_bench_io_buffers(mimic_bench_crc32_ieee, 0, tc_src, &crc32_pi_gt, 0,
-                             0, 150);
+  return do_bench_io_buffers(mimic_bench_crc32_ieee, 0, tc_src, &crc32_pi_gt,
+                             UINT64_MAX, UINT64_MAX, 150);
 }
 
 #endif  // WUFFS_MIMIC
diff --git a/test/c/std/deflate.c b/test/c/std/deflate.c
index b011709..ae6d8e6 100644
--- a/test/c/std/deflate.c
+++ b/test/c/std/deflate.c
@@ -149,19 +149,21 @@
 
   while (true) {
     wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(dst);
-    if (wlimit) {
+    if (wlimit < UINT64_MAX) {
       set_writer_limit(&dst_writer, wlimit);
     }
     wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(src);
-    if (rlimit) {
+    if (rlimit < UINT64_MAX) {
       set_reader_limit(&src_reader, rlimit);
     }
 
     status = wuffs_deflate__decoder__decode_io_writer(
         &dec, dst_writer, src_reader, global_work_slice);
 
-    if ((wlimit && (status == wuffs_base__suspension__short_write)) ||
-        (rlimit && (status == wuffs_base__suspension__short_read))) {
+    if (((wlimit < UINT64_MAX) &&
+         (status == wuffs_base__suspension__short_write)) ||
+        ((rlimit < UINT64_MAX) &&
+         (status == wuffs_base__suspension__short_read))) {
       continue;
     }
     return status;
@@ -170,25 +172,29 @@
 
 const char* test_wuffs_deflate_decode_256_bytes() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(wuffs_deflate_decode, &deflate_256_bytes_gt, 0, 0);
+  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() {
   CHECK_FOCUS(__func__);
   return do_test_io_buffers(wuffs_deflate_decode,
-                            &deflate_deflate_backref_crosses_blocks_gt, 0, 0);
+                            &deflate_deflate_backref_crosses_blocks_gt,
+                            UINT64_MAX, UINT64_MAX);
 }
 
 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, 0, 0);
+                            &deflate_deflate_distance_32768_gt, UINT64_MAX,
+                            UINT64_MAX);
 }
 
 const char* test_wuffs_deflate_decode_deflate_distance_code_31() {
   CHECK_FOCUS(__func__);
-  const char* got = do_test_io_buffers(
-      wuffs_deflate_decode, &deflate_deflate_distance_code_31_gt, 0, 0);
+  const char* got = do_test_io_buffers(wuffs_deflate_decode,
+                                       &deflate_deflate_distance_code_31_gt,
+                                       UINT64_MAX, UINT64_MAX);
   if (got != wuffs_deflate__error__bad_huffman_code) {
     RETURN_FAIL("got \"%s\", want \"%s\"", got,
                 wuffs_deflate__error__bad_huffman_code);
@@ -198,22 +204,26 @@
 
 const char* test_wuffs_deflate_decode_midsummer() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(wuffs_deflate_decode, &deflate_midsummer_gt, 0, 0);
+  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() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 0, 0);
+  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() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 0, 4096);
+  return do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, UINT64_MAX,
+                            4096);
 }
 
 const char* test_wuffs_deflate_decode_pi_many_medium_reads() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 0, 599);
+  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() {
@@ -223,13 +233,14 @@
 
 const char* test_wuffs_deflate_decode_romeo() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(wuffs_deflate_decode, &deflate_romeo_gt, 0, 0);
+  return do_test_io_buffers(wuffs_deflate_decode, &deflate_romeo_gt, UINT64_MAX,
+                            UINT64_MAX);
 }
 
 const char* test_wuffs_deflate_decode_romeo_fixed() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(wuffs_deflate_decode, &deflate_romeo_fixed_gt, 0,
-                            0);
+  return do_test_io_buffers(wuffs_deflate_decode, &deflate_romeo_fixed_gt,
+                            UINT64_MAX, UINT64_MAX);
 }
 
 const char* test_wuffs_deflate_decode_split_src() {
@@ -312,7 +323,7 @@
                                           wuffs_base__io_buffer* got,
                                           wuffs_deflate__decoder* dec,
                                           uint32_t starting_history_index,
-                                          uint64_t limit,
+                                          uint64_t wlimit,
                                           const char* want_z) {
   src->meta.ri = gt->src_offset0;
   src->meta.wi = gt->src_offset1;
@@ -324,7 +335,7 @@
 
   dec->private_impl.f_history_index = starting_history_index;
 
-  set_writer_limit(&dst_writer, limit);
+  set_writer_limit(&dst_writer, wlimit);
 
   const char* got_z = wuffs_deflate__decoder__decode_io_writer(
       dec, dst_writer, src_reader, global_work_slice);
@@ -624,25 +635,29 @@
 
 const char* test_mimic_deflate_decode_256_bytes() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(mimic_deflate_decode, &deflate_256_bytes_gt, 0, 0);
+  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() {
   CHECK_FOCUS(__func__);
   return do_test_io_buffers(mimic_deflate_decode,
-                            &deflate_deflate_backref_crosses_blocks_gt, 0, 0);
+                            &deflate_deflate_backref_crosses_blocks_gt,
+                            UINT64_MAX, UINT64_MAX);
 }
 
 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, 0, 0);
+                            &deflate_deflate_distance_32768_gt, UINT64_MAX,
+                            UINT64_MAX);
 }
 
 const char* test_mimic_deflate_decode_deflate_distance_code_31() {
   CHECK_FOCUS(__func__);
-  const char* got = do_test_io_buffers(
-      mimic_deflate_decode, &deflate_deflate_distance_code_31_gt, 0, 0);
+  const char* got = do_test_io_buffers(mimic_deflate_decode,
+                                       &deflate_deflate_distance_code_31_gt,
+                                       UINT64_MAX, UINT64_MAX);
   const char* want = "inflate failed (data error)";
   if ((got != want) && ((got == NULL) || (want == NULL) || strcmp(got, want))) {
     RETURN_FAIL("got \"%s\", want \"%s\"", got, want);
@@ -652,28 +667,32 @@
 
 const char* test_mimic_deflate_decode_midsummer() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(mimic_deflate_decode, &deflate_midsummer_gt, 0, 0);
+  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() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(mimic_deflate_decode, &deflate_pi_gt, 0, 0);
+  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() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(mimic_deflate_decode, &deflate_pi_gt, 0, 4096);
+  return do_test_io_buffers(mimic_deflate_decode, &deflate_pi_gt, UINT64_MAX,
+                            4096);
 }
 
 const char* test_mimic_deflate_decode_romeo() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(mimic_deflate_decode, &deflate_romeo_gt, 0, 0);
+  return do_test_io_buffers(mimic_deflate_decode, &deflate_romeo_gt, UINT64_MAX,
+                            UINT64_MAX);
 }
 
 const char* test_mimic_deflate_decode_romeo_fixed() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(mimic_deflate_decode, &deflate_romeo_fixed_gt, 0,
-                            0);
+  return do_test_io_buffers(mimic_deflate_decode, &deflate_romeo_fixed_gt,
+                            UINT64_MAX, UINT64_MAX);
 }
 
 #endif  // WUFFS_MIMIC
@@ -684,7 +703,7 @@
   CHECK_FOCUS(__func__);
   return do_bench_io_buffers(wuffs_deflate_decode,
                              WUFFS_INITIALIZE__DEFAULT_OPTIONS, tc_dst,
-                             &deflate_romeo_gt, 0, 0, 2000);
+                             &deflate_romeo_gt, UINT64_MAX, UINT64_MAX, 2000);
 }
 
 const char* bench_wuffs_deflate_decode_1k_part_init() {
@@ -692,14 +711,14 @@
   return do_bench_io_buffers(
       wuffs_deflate_decode,
       WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tc_dst,
-      &deflate_romeo_gt, 0, 0, 2000);
+      &deflate_romeo_gt, UINT64_MAX, UINT64_MAX, 2000);
 }
 
 const char* bench_wuffs_deflate_decode_10k_full_init() {
   CHECK_FOCUS(__func__);
-  return do_bench_io_buffers(wuffs_deflate_decode,
-                             WUFFS_INITIALIZE__DEFAULT_OPTIONS, tc_dst,
-                             &deflate_midsummer_gt, 0, 0, 300);
+  return do_bench_io_buffers(
+      wuffs_deflate_decode, WUFFS_INITIALIZE__DEFAULT_OPTIONS, tc_dst,
+      &deflate_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
 }
 
 const char* bench_wuffs_deflate_decode_10k_part_init() {
@@ -707,7 +726,7 @@
   return do_bench_io_buffers(
       wuffs_deflate_decode,
       WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tc_dst,
-      &deflate_midsummer_gt, 0, 0, 300);
+      &deflate_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
 }
 
 const char* bench_wuffs_deflate_decode_100k_just_one_read() {
@@ -715,7 +734,7 @@
   return do_bench_io_buffers(
       wuffs_deflate_decode,
       WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tc_dst,
-      &deflate_pi_gt, 0, 0, 30);
+      &deflate_pi_gt, UINT64_MAX, UINT64_MAX, 30);
 }
 
 const char* bench_wuffs_deflate_decode_100k_many_big_reads() {
@@ -723,7 +742,7 @@
   return do_bench_io_buffers(
       wuffs_deflate_decode,
       WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tc_dst,
-      &deflate_pi_gt, 0, 4096, 30);
+      &deflate_pi_gt, UINT64_MAX, 4096, 30);
 }
 
   // ---------------- Mimic Benches
@@ -733,25 +752,26 @@
 const char* bench_mimic_deflate_decode_1k() {
   CHECK_FOCUS(__func__);
   return do_bench_io_buffers(mimic_deflate_decode, 0, tc_dst, &deflate_romeo_gt,
-                             0, 0, 2000);
+                             UINT64_MAX, UINT64_MAX, 2000);
 }
 
 const char* bench_mimic_deflate_decode_10k() {
   CHECK_FOCUS(__func__);
   return do_bench_io_buffers(mimic_deflate_decode, 0, tc_dst,
-                             &deflate_midsummer_gt, 0, 0, 300);
+                             &deflate_midsummer_gt, UINT64_MAX, UINT64_MAX,
+                             300);
 }
 
 const char* bench_mimic_deflate_decode_100k_just_one_read() {
   CHECK_FOCUS(__func__);
-  return do_bench_io_buffers(mimic_deflate_decode, 0, tc_dst, &deflate_pi_gt, 0,
-                             0, 30);
+  return do_bench_io_buffers(mimic_deflate_decode, 0, tc_dst, &deflate_pi_gt,
+                             UINT64_MAX, UINT64_MAX, 30);
 }
 
 const char* bench_mimic_deflate_decode_100k_many_big_reads() {
   CHECK_FOCUS(__func__);
-  return do_bench_io_buffers(mimic_deflate_decode, 0, tc_dst, &deflate_pi_gt, 0,
-                             4096, 30);
+  return do_bench_io_buffers(mimic_deflate_decode, 0, tc_dst, &deflate_pi_gt,
+                             UINT64_MAX, 4096, 30);
 }
 
 #endif  // WUFFS_MIMIC
diff --git a/test/c/std/gif.c b/test/c/std/gif.c
index 876bb9f..ab379a1 100644
--- a/test/c/std/gif.c
+++ b/test/c/std/gif.c
@@ -325,7 +325,7 @@
   while (true) {
     num_iters++;
     wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
-    if (rlimit) {
+    if (rlimit < UINT64_MAX) {
       set_reader_limit(&src_reader, rlimit);
     }
     size_t old_ri = src.meta.ri;
@@ -351,7 +351,7 @@
   while (true) {
     num_iters++;
     wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
-    if (rlimit) {
+    if (rlimit < UINT64_MAX) {
       set_reader_limit(&src_reader, rlimit);
     }
     size_t old_ri = src.meta.ri;
@@ -381,7 +381,7 @@
     return status;
   }
 
-  if (rlimit) {
+  if (rlimit < UINT64_MAX) {
     if (num_iters <= 2) {
       RETURN_FAIL("num_iters: got %d, want > 2", num_iters);
     }
@@ -1184,31 +1184,33 @@
 
 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",
-      "test/data/bricks-dither.indexes", 0, WUFFS_BASE__PIXEL_FORMAT__BGR);
+  return do_test_wuffs_gif_decode("test/data/bricks-dither.gif",
+                                  "test/data/bricks-dither.palette",
+                                  "test/data/bricks-dither.indexes", UINT64_MAX,
+                                  WUFFS_BASE__PIXEL_FORMAT__BGR);
 }
 
 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",
-                                  "test/data/bricks-dither.indexes", 0,
+                                  "test/data/bricks-dither.indexes", UINT64_MAX,
                                   WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL);
 }
 
 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",
-      "test/data/bricks-dither.indexes", 0, WUFFS_BASE__PIXEL_FORMAT__RGB);
+  return do_test_wuffs_gif_decode("test/data/bricks-dither.gif",
+                                  "test/data/bricks-dither.palette",
+                                  "test/data/bricks-dither.indexes", UINT64_MAX,
+                                  WUFFS_BASE__PIXEL_FORMAT__RGB);
 }
 
 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",
-                                  "test/data/bricks-dither.indexes", 0,
+                                  "test/data/bricks-dither.indexes", UINT64_MAX,
                                   WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL);
 }
 
@@ -1216,7 +1218,7 @@
   CHECK_FOCUS(__func__);
   return do_test_wuffs_gif_decode(
       "test/data/bricks-dither.gif", "test/data/bricks-dither.palette",
-      "test/data/bricks-dither.indexes", 0,
+      "test/data/bricks-dither.indexes", UINT64_MAX,
       WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY);
 }
 
diff --git a/test/c/std/gzip.c b/test/c/std/gzip.c
index 830d605..251c8db 100644
--- a/test/c/std/gzip.c
+++ b/test/c/std/gzip.c
@@ -97,19 +97,21 @@
 
   while (true) {
     wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(dst);
-    if (wlimit) {
+    if (wlimit < UINT64_MAX) {
       set_writer_limit(&dst_writer, wlimit);
     }
     wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(src);
-    if (rlimit) {
+    if (rlimit < UINT64_MAX) {
       set_reader_limit(&src_reader, rlimit);
     }
 
     status = wuffs_gzip__decoder__decode_io_writer(&dec, dst_writer, src_reader,
                                                    global_work_slice);
 
-    if ((wlimit && (status == wuffs_base__suspension__short_write)) ||
-        (rlimit && (status == wuffs_base__suspension__short_read))) {
+    if (((wlimit < UINT64_MAX) &&
+         (status == wuffs_base__suspension__short_write)) ||
+        ((rlimit < UINT64_MAX) &&
+         (status == wuffs_base__suspension__short_read))) {
       continue;
     }
     return status;
@@ -138,7 +140,7 @@
     src.data.ptr[src.meta.wi - 1 - (bad_checksum & 7)] ^= 1;
   }
 
-  int end_limit;
+  int end_limit;  // The rlimit, relative to the end of the data.
   for (end_limit = 0; end_limit < 10; end_limit++) {
     wuffs_gzip__decoder dec;
     status = wuffs_gzip__decoder__initialize(
@@ -206,12 +208,14 @@
 
 const char* test_wuffs_gzip_decode_midsummer() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(wuffs_gzip_decode, &gzip_midsummer_gt, 0, 0);
+  return do_test_io_buffers(wuffs_gzip_decode, &gzip_midsummer_gt, UINT64_MAX,
+                            UINT64_MAX);
 }
 
 const char* test_wuffs_gzip_decode_pi() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(wuffs_gzip_decode, &gzip_pi_gt, 0, 0);
+  return do_test_io_buffers(wuffs_gzip_decode, &gzip_pi_gt, UINT64_MAX,
+                            UINT64_MAX);
 }
 
   // ---------------- Mimic Tests
@@ -220,12 +224,14 @@
 
 const char* test_mimic_gzip_decode_midsummer() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(mimic_gzip_decode, &gzip_midsummer_gt, 0, 0);
+  return do_test_io_buffers(mimic_gzip_decode, &gzip_midsummer_gt, UINT64_MAX,
+                            UINT64_MAX);
 }
 
 const char* test_mimic_gzip_decode_pi() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(mimic_gzip_decode, &gzip_pi_gt, 0, 0);
+  return do_test_io_buffers(mimic_gzip_decode, &gzip_pi_gt, UINT64_MAX,
+                            UINT64_MAX);
 }
 
 #endif  // WUFFS_MIMIC
@@ -236,14 +242,14 @@
   CHECK_FOCUS(__func__);
   return do_bench_io_buffers(
       wuffs_gzip_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
-      tc_dst, &gzip_midsummer_gt, 0, 0, 300);
+      tc_dst, &gzip_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
 }
 
 const char* bench_wuffs_gzip_decode_100k() {
   CHECK_FOCUS(__func__);
   return do_bench_io_buffers(
       wuffs_gzip_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
-      tc_dst, &gzip_pi_gt, 0, 0, 30);
+      tc_dst, &gzip_pi_gt, UINT64_MAX, UINT64_MAX, 30);
 }
 
   // ---------------- Mimic Benches
@@ -253,13 +259,13 @@
 const char* bench_mimic_gzip_decode_10k() {
   CHECK_FOCUS(__func__);
   return do_bench_io_buffers(mimic_gzip_decode, 0, tc_dst, &gzip_midsummer_gt,
-                             0, 0, 300);
+                             UINT64_MAX, UINT64_MAX, 300);
 }
 
 const char* bench_mimic_gzip_decode_100k() {
   CHECK_FOCUS(__func__);
-  return do_bench_io_buffers(mimic_gzip_decode, 0, tc_dst, &gzip_pi_gt, 0, 0,
-                             30);
+  return do_bench_io_buffers(mimic_gzip_decode, 0, tc_dst, &gzip_pi_gt,
+                             UINT64_MAX, UINT64_MAX, 30);
 }
 
 #endif  // WUFFS_MIMIC
diff --git a/test/c/std/lzw.c b/test/c/std/lzw.c
index a6a1ca8..9101b1b 100644
--- a/test/c/std/lzw.c
+++ b/test/c/std/lzw.c
@@ -119,11 +119,11 @@
   while (true) {
     num_iters++;
     wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got);
-    if (wlimit) {
+    if (wlimit < UINT64_MAX) {
       set_writer_limit(&got_writer, wlimit);
     }
     wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
-    if (rlimit) {
+    if (rlimit < UINT64_MAX) {
       set_reader_limit(&src_reader, rlimit);
     }
     size_t old_wi = got.meta.wi;
@@ -155,7 +155,7 @@
     }
   }
 
-  if (wlimit || rlimit) {
+  if ((wlimit < UINT64_MAX) || (rlimit < UINT64_MAX)) {
     if (num_iters <= 1) {
       RETURN_FAIL("num_iters: got %d, want > 1", num_iters);
     }
@@ -172,21 +172,21 @@
   CHECK_FOCUS(__func__);
   return do_test_wuffs_lzw_decode("test/data/bricks-dither.indexes.giflzw",
                                   14923, "test/data/bricks-dither.indexes",
-                                  19200, 0, 0);
+                                  19200, UINT64_MAX, UINT64_MAX);
 }
 
 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, 0, 0);
+                                  19200, UINT64_MAX, UINT64_MAX);
 }
 
 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, 0,
-                                  4096);
+                                  "test/data/bricks-gray.indexes", 19200,
+                                  UINT64_MAX, 4096);
 }
 
 const char* test_wuffs_lzw_decode_many_small_writes_reads() {
@@ -199,7 +199,8 @@
 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, 0, 0);
+                                  "test/data/pi.txt", 100003, UINT64_MAX,
+                                  UINT64_MAX);
 }
 
 const char* test_wuffs_lzw_decode_output_bad() {
diff --git a/test/c/std/zlib.c b/test/c/std/zlib.c
index 726d4a4..d89e95e 100644
--- a/test/c/std/zlib.c
+++ b/test/c/std/zlib.c
@@ -97,19 +97,21 @@
 
   while (true) {
     wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(dst);
-    if (wlimit) {
+    if (wlimit < UINT64_MAX) {
       set_writer_limit(&dst_writer, wlimit);
     }
     wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(src);
-    if (rlimit) {
+    if (rlimit < UINT64_MAX) {
       set_reader_limit(&src_reader, rlimit);
     }
 
     status = wuffs_zlib__decoder__decode_io_writer(&dec, dst_writer, src_reader,
                                                    global_work_slice);
 
-    if ((wlimit && (status == wuffs_base__suspension__short_write)) ||
-        (rlimit && (status == wuffs_base__suspension__short_read))) {
+    if (((wlimit < UINT64_MAX) &&
+         (status == wuffs_base__suspension__short_write)) ||
+        ((rlimit < UINT64_MAX) &&
+         (status == wuffs_base__suspension__short_read))) {
       continue;
     }
     return status;
@@ -137,7 +139,7 @@
     src.data.ptr[src.meta.wi - 1 - (bad_checksum & 3)] ^= 1;
   }
 
-  int end_limit;
+  int end_limit;  // The rlimit, relative to the end of the data.
   for (end_limit = 0; end_limit < 10; end_limit++) {
     wuffs_zlib__decoder dec;
     status = wuffs_zlib__decoder__initialize(
@@ -205,12 +207,14 @@
 
 const char* test_wuffs_zlib_decode_midsummer() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(wuffs_zlib_decode, &zlib_midsummer_gt, 0, 0);
+  return do_test_io_buffers(wuffs_zlib_decode, &zlib_midsummer_gt, UINT64_MAX,
+                            UINT64_MAX);
 }
 
 const char* test_wuffs_zlib_decode_pi() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(wuffs_zlib_decode, &zlib_pi_gt, 0, 0);
+  return do_test_io_buffers(wuffs_zlib_decode, &zlib_pi_gt, UINT64_MAX,
+                            UINT64_MAX);
 }
 
   // ---------------- Mimic Tests
@@ -219,12 +223,14 @@
 
 const char* test_mimic_zlib_decode_midsummer() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(mimic_zlib_decode, &zlib_midsummer_gt, 0, 0);
+  return do_test_io_buffers(mimic_zlib_decode, &zlib_midsummer_gt, UINT64_MAX,
+                            UINT64_MAX);
 }
 
 const char* test_mimic_zlib_decode_pi() {
   CHECK_FOCUS(__func__);
-  return do_test_io_buffers(mimic_zlib_decode, &zlib_pi_gt, 0, 0);
+  return do_test_io_buffers(mimic_zlib_decode, &zlib_pi_gt, UINT64_MAX,
+                            UINT64_MAX);
 }
 
 #endif  // WUFFS_MIMIC
@@ -235,14 +241,14 @@
   CHECK_FOCUS(__func__);
   return do_bench_io_buffers(
       wuffs_zlib_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
-      tc_dst, &zlib_midsummer_gt, 0, 0, 300);
+      tc_dst, &zlib_midsummer_gt, UINT64_MAX, UINT64_MAX, 300);
 }
 
 const char* bench_wuffs_zlib_decode_100k() {
   CHECK_FOCUS(__func__);
   return do_bench_io_buffers(
       wuffs_zlib_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
-      tc_dst, &zlib_pi_gt, 0, 0, 30);
+      tc_dst, &zlib_pi_gt, UINT64_MAX, UINT64_MAX, 30);
 }
 
   // ---------------- Mimic Benches
@@ -252,13 +258,13 @@
 const char* bench_mimic_zlib_decode_10k() {
   CHECK_FOCUS(__func__);
   return do_bench_io_buffers(mimic_zlib_decode, 0, tc_dst, &zlib_midsummer_gt,
-                             0, 0, 300);
+                             UINT64_MAX, UINT64_MAX, 300);
 }
 
 const char* bench_mimic_zlib_decode_100k() {
   CHECK_FOCUS(__func__);
-  return do_bench_io_buffers(mimic_zlib_decode, 0, tc_dst, &zlib_pi_gt, 0, 0,
-                             30);
+  return do_bench_io_buffers(mimic_zlib_decode, 0, tc_dst, &zlib_pi_gt,
+                             UINT64_MAX, UINT64_MAX, 30);
 }
 
 #endif  // WUFFS_MIMIC