7 files changed, 293 insertions, 67 deletions

diff --git a/tests/runner.c b/tests/runner.c
index 148b928..9e5c99f 100644
--- a/tests/runner.c
+++ b/tests/runner.c
@@ -14,7 +14,7 @@ struct module {
   void (*run)(void);
 };
 
-static const struct module modules[] = {{"scan_urlencoded_query", test_scan_urlencoded_query},
+static const struct module modules[] = {{"ot_urlencoded", test_urlencoded},
                                         {"ot_iovec", test_iovec},
                                         {"ot_vector", test_vector},
                                         {"ot_random", test_random},
@@ -25,6 +25,7 @@ static const struct module modules[] = {{"scan_urlencoded_query", test_scan_urle
                                         {"ot_socket", test_socket},
                                         {"ot_mutex", test_mutex},
                                         {"ot_batch", test_batch},
+                                        {"ot_fdstate", test_fdstate},
                                         {"ot_accesslist", test_accesslist},
                                         {NULL, NULL}};
 
diff --git a/tests/t_fdstate.c b/tests/t_fdstate.c
new file mode 100644
index 0000000..bf8724a
--- /dev/null
+++ b/tests/t_fdstate.c
@@ -0,0 +1,224 @@
+/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
+   It is considered beerware. Prost. Skol. Cheers or whatever.
+
+   $id$ */
+
+/* System */
+#include <pthread.h>
+#include <stdatomic.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Opentracker */
+#include "ot_fdstate.h"
+#include "test.h"
+
+/* ------------------------------------------------------- one thread first */
+
+static void case_open_claim_release(void) {
+  char     cookie[4];
+  uint32_t generation;
+
+  test_case("a descriptor taken into the table can be claimed and gives back its cookie");
+  generation = fdstate_open(7, cookie, 0);
+  CHECK_INT(fdstate_claim(7, generation), 1);
+  CHECK_PTR(fdstate_cookie(7), cookie);
+  fdstate_release(7);
+
+  test_case("and can be claimed again once released");
+  CHECK_INT(fdstate_claim(7, generation), 1);
+  fdstate_release(7);
+  fdstate_close(7);
+}
+
+static void case_one_holder_at_a_time(void) {
+  uint32_t generation = fdstate_open(8, NULL, 0);
+
+  test_case("a descriptor somebody holds cannot be claimed again");
+  CHECK_INT(fdstate_claim(8, generation), 1);
+  CHECK_INT(fdstate_claim(8, generation), 0);
+  fdstate_release(8);
+  CHECK_INT(fdstate_claim(8, generation), 1);
+  fdstate_release(8);
+  fdstate_close(8);
+}
+
+static void case_stale_generation_is_refused(void) {
+  char     first[4], second[4];
+  uint32_t old, new;
+
+  test_case("a caller quoting the generation of a closed descriptor is turned away");
+  old = fdstate_open(9, first, 0);
+  fdstate_close(9);
+  new = fdstate_open(9, second, 0);
+  CHECK(old != new);
+  CHECK_INT(fdstate_claim(9, old), 0);
+
+  test_case("while the one quoting the new generation gets the new cookie");
+  CHECK_INT(fdstate_claim(9, new), 1);
+  CHECK_PTR(fdstate_cookie(9), second);
+  fdstate_release(9);
+  fdstate_close(9);
+}
+
+static void case_expiry(void) {
+  uint32_t generation = fdstate_open(10, NULL, 100);
+
+  test_case("a descriptor past its expiry is collected");
+  CHECK_INT(fdstate_claim_expired(10, 99), 0);
+  CHECK_INT(fdstate_claim_expired(10, 100), 1);
+  fdstate_close(10);
+
+  test_case("one that never expires is never collected");
+  generation = fdstate_open(10, NULL, 0);
+  CHECK_INT(fdstate_claim_expired(10, 1 << 30), 0);
+
+  test_case("and one somebody is working on is left alone");
+  fdstate_set_expiry(10, 1);
+  CHECK_INT(fdstate_claim(10, generation), 1);
+  CHECK_INT(fdstate_claim_expired(10, 1 << 30), 0);
+  fdstate_release(10);
+  CHECK_INT(fdstate_claim_expired(10, 1 << 30), 1);
+  fdstate_close(10);
+}
+
+static void case_out_of_range(void) {
+  test_case("a descriptor outside the table is refused rather than trusted");
+  CHECK_INT(fdstate_claim(-1, 0), 0);
+  CHECK_INT(fdstate_claim((int)fdstate_slots(), 0), 0);
+  CHECK_INT(fdstate_claim_expired(-1, 0), 0);
+  CHECK_PTR(fdstate_cookie(-1), NULL);
+}
+
+/* --------------------------------------------------------- then in anger */
+
+/* The race this is about only exists while a descriptor is being recycled,
+   so recycling is driven by work done rather than by a clock: every slot is
+   given up after RECYCLE_AFTER claims, whatever the machine's speed. */
+
+#define STRESS_SLOTS   64
+#define RECYCLE_AFTER  32
+#define STRESS_CLAIMS  200000
+#define STRESS_GIVEUP  (STRESS_CLAIMS * 100)
+
+static _Atomic long     stress_claims, stress_recycles, stress_violations, stress_attempts;
+static _Atomic int      stress_lives[STRESS_SLOTS];
+static _Atomic int      stress_live[STRESS_SLOTS];
+
+/* Generation and cookie are published in one word so a worker can never read
+   a cookie that belongs to a different generation than the one it claimed
+   with. Each connection gets a cookie nobody else ever gets. */
+static _Atomic uint64_t stress_conn[STRESS_SLOTS];
+static _Atomic uint64_t stress_next_cookie;
+
+#define STRESS_CONN(cookie, gen) (((uint64_t)(cookie) << 32) | (uint32_t)(gen))
+#define STRESS_CONN_COOKIE(w)    ((void *)(uintptr_t)((w) >> 32))
+#define STRESS_CONN_GEN(w)       ((uint32_t)(w))
+
+static int stress_running(void) {
+  return atomic_load(&stress_claims) < STRESS_CLAIMS && atomic_load(&stress_attempts) < STRESS_GIVEUP;
+}
+
+static void *stress_worker(void *arg) {
+  unsigned seed = (unsigned)(uintptr_t)arg;
+
+  while (stress_running()) {
+    int      fd   = (int)(rand_r(&seed) % STRESS_SLOTS);
+    uint64_t conn = atomic_load(&stress_conn[fd]);
+
+    atomic_fetch_add(&stress_attempts, 1);
+    if (!fdstate_claim(fd, STRESS_CONN_GEN(conn)))
+      continue;
+
+    if (fdstate_cookie(fd) != STRESS_CONN_COOKIE(conn))
+      atomic_fetch_add(&stress_violations, 1);
+    if (atomic_fetch_sub(&stress_lives[fd], 1) <= 1)
+      fdstate_set_expiry(fd, 1); /* retired by its holder, as a handler would */
+    if (fdstate_cookie(fd) != STRESS_CONN_COOKIE(conn))
+      atomic_fetch_add(&stress_violations, 1);
+
+    fdstate_release(fd);
+    atomic_fetch_add(&stress_claims, 1);
+  }
+  return NULL;
+}
+
+static void *stress_keeper(void *arg) {
+  (void)arg;
+  while (stress_running()) {
+    int fd;
+
+    for (fd = 0; fd < STRESS_SLOTS; ++fd) {
+      if (atomic_load(&stress_live[fd])) {
+        if (!fdstate_claim_expired(fd, 1))
+          continue;                            /* a worker has it, come back */
+        fdstate_close(fd);
+        atomic_store(&stress_live[fd], 0);
+        atomic_fetch_add(&stress_recycles, 1);
+      }
+      {
+        void    *cookie = (void *)(uintptr_t)(atomic_fetch_add(&stress_next_cookie, 1) + 1);
+        uint32_t gen    = fdstate_open(fd, cookie, 0);
+
+        atomic_store(&stress_lives[fd], RECYCLE_AFTER);
+        atomic_store(&stress_conn[fd], STRESS_CONN((uintptr_t)cookie, gen));
+        atomic_store(&stress_live[fd], 1);
+      }
+    }
+  }
+  return NULL;
+}
+
+static void case_recycling_under_load(void) {
+  pthread_t worker[4], keeper;
+  size_t    i;
+
+  test_case("no worker is ever handed a connection from another generation");
+  atomic_store(&stress_claims, 0);
+  atomic_store(&stress_recycles, 0);
+  atomic_store(&stress_violations, 0);
+  atomic_store(&stress_attempts, 0);
+  atomic_store(&stress_next_cookie, 0);
+  /* Every slot is opened and published before any worker runs: a worker only
+     ever learns of a descriptor from whoever registered it, and never
+     invents a generation of its own. */
+  for (i = 0; i < STRESS_SLOTS; ++i) {
+    void    *cookie = (void *)(uintptr_t)(atomic_fetch_add(&stress_next_cookie, 1) + 1);
+    uint32_t gen    = fdstate_open((int)i, cookie, 0);
+
+    atomic_store(&stress_lives[i], RECYCLE_AFTER);
+    atomic_store(&stress_conn[i], STRESS_CONN((uintptr_t)cookie, gen));
+    atomic_store(&stress_live[i], 1);
+  }
+
+  pthread_create(&keeper, NULL, stress_keeper, NULL);
+  for (i = 0; i < sizeof(worker) / sizeof(worker[0]); ++i)
+    pthread_create(&worker[i], NULL, stress_worker, (void *)(uintptr_t)(i + 1));
+  for (i = 0; i < sizeof(worker) / sizeof(worker[0]); ++i)
+    pthread_join(worker[i], NULL);
+  pthread_join(keeper, NULL);
+
+  CHECK_INT(atomic_load(&stress_violations), 0);
+
+  test_case("and the run actually recycled descriptors, or it proved nothing");
+  CHECK(atomic_load(&stress_claims) >= STRESS_CLAIMS);
+  CHECK(atomic_load(&stress_recycles) > STRESS_CLAIMS / (RECYCLE_AFTER * 4));
+
+  for (i = 0; i < STRESS_SLOTS; ++i)
+    fdstate_close((int)i);
+}
+
+void test_fdstate(void) {
+  CHECK_INT(fdstate_init(), 0);
+  CHECK(fdstate_slots() > STRESS_SLOTS);
+
+  case_open_claim_release();
+  case_one_holder_at_a_time();
+  case_stale_generation_is_refused();
+  case_expiry();
+  case_out_of_range();
+  case_recycling_under_load();
+
+  fdstate_deinit();
+}
diff --git a/tests/t_hex.c b/tests/t_hex.c
index 7cce8ac..a761737 100644
--- a/tests/t_hex.c
+++ b/tests/t_hex.c
@@ -18,7 +18,7 @@ static void case_encode(void) {
 
   test_case("a hash encodes to forty upper case digits and a terminator");
   memset(dest, 0x7f, sizeof(dest));
-  CHECK_PTR(hex_fromhash(dest, sample), dest);
+  CHECK_PTR(hex_from_hash(dest, sample), dest);
   CHECK_STR(dest, "000123456789ABCDEFFF10203040506070809" "0A0");
   CHECK_INT(strlen(dest), 40);
   CHECK_INT((unsigned char)dest[41], 0x7f);
@@ -28,7 +28,7 @@ static void case_decode(void) {
   ot_hash hash;
 
   test_case("forty digits decode back to the hash");
-  CHECK(hex_tohash(hash, "000123456789ABCDEFFF10203040506070809" "0A0"));
+  CHECK(hex_to_hash(hash, "000123456789ABCDEFFF10203040506070809" "0A0"));
   CHECK_MEM(hash, sample, sizeof(sample));
 }
 
@@ -41,8 +41,8 @@ static void case_round_trip(void) {
   for (i = 0; i < 256; ++i) {
     uint8_t probe[20];
     memset(probe, (uint8_t)i, sizeof(probe));
-    hex_fromhash(text, probe);
-    if (!hex_tohash(hash, text) || memcmp(hash, probe, sizeof(probe))) {
+    hex_from_hash(text, probe);
+    if (!hex_to_hash(hash, text) || memcmp(hash, probe, sizeof(probe))) {
       test_failf(__FILE__, __LINE__, "round trip failed for byte value %zu", i);
       return;
     }
@@ -54,8 +54,8 @@ static void case_decode_is_case_insensitive(void) {
   ot_hash upper, lower;
 
   test_case("lower case digits decode the same as upper case");
-  CHECK(hex_tohash(upper, "ABCDEF0123456789ABCDEF0123456789ABCDEF01"));
-  CHECK(hex_tohash(lower, "abcdef0123456789abcdef0123456789abcdef01"));
+  CHECK(hex_to_hash(upper, "ABCDEF0123456789ABCDEF0123456789ABCDEF01"));
+  CHECK(hex_to_hash(lower, "abcdef0123456789abcdef0123456789abcdef01"));
   CHECK_MEM(lower, upper, sizeof(ot_hash));
 }
 
@@ -63,18 +63,18 @@ static void case_rejects_non_digits(void) {
   ot_hash hash;
 
   test_case("a non hex character anywhere rejects the whole string");
-  CHECK_INT(hex_tohash(hash, "g00123456789ABCDEFFF102030405060708090A0"), 0);
-  CHECK_INT(hex_tohash(hash, "000123456789ABCDEFFF102030405060708090Ag"), 0);
-  CHECK_INT(hex_tohash(hash, "000123456789ABCDEF:F102030405060708090A"), 0);
+  CHECK_INT(hex_to_hash(hash, "g00123456789ABCDEFFF102030405060708090A0"), 0);
+  CHECK_INT(hex_to_hash(hash, "000123456789ABCDEFFF102030405060708090Ag"), 0);
+  CHECK_INT(hex_to_hash(hash, "000123456789ABCDEF:F102030405060708090A"), 0);
 }
 
 static void case_rejects_short_input(void) {
   ot_hash hash;
 
   test_case("a string shorter than forty digits is rejected");
-  CHECK_INT(hex_tohash(hash, ""), 0);
-  CHECK_INT(hex_tohash(hash, "00"), 0);
-  CHECK_INT(hex_tohash(hash, "000123456789ABCDEFFF102030405060708090A"), 0);
+  CHECK_INT(hex_to_hash(hash, ""), 0);
+  CHECK_INT(hex_to_hash(hash, "00"), 0);
+  CHECK_INT(hex_to_hash(hash, "000123456789ABCDEFFF102030405060708090A"), 0);
 }
 
 static void case_leaves_hash_untouched_on_failure(void) {
@@ -82,7 +82,7 @@ static void case_leaves_hash_untouched_on_failure(void) {
 
   test_case("a rejected string leaves the destination untouched");
   memset(hash, 0x5a, sizeof(hash));
-  CHECK_INT(hex_tohash(hash, "000123456789ABCDEFFF10203040506070809XX0"), 0);
+  CHECK_INT(hex_to_hash(hash, "000123456789ABCDEFFF10203040506070809XX0"), 0);
   CHECK_MEM(hash, "\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a\x5a", sizeof(hash));
 }
 
@@ -96,7 +96,7 @@ static void case_stops_at_the_terminator(void) {
   memcpy(guarded, "0012", 4);
   guarded[4] = 0;
   memset(guarded + 5, 'f', 3);
-  CHECK_INT(hex_tohash(hash, guarded), 0);
+  CHECK_INT(hex_to_hash(hash, guarded), 0);
 }
 
 static void case_isdigit(void) {
diff --git a/tests/t_iovec.c b/tests/t_iovec.c
index 89f3fda..2553141 100644
--- a/tests/t_iovec.c
+++ b/tests/t_iovec.c
@@ -18,13 +18,13 @@ static void case_increase_and_length(void) {
   void         *first, *second;
 
   test_case("increase appends an entry and length is their sum");
-  first = iovec_increase(&entries, &vector, 100);
+  first = iovec_new_chunk(&entries, &vector, 100);
   CHECK(first != NULL);
   CHECK_INT(entries, 1);
   CHECK_INT(vector[0].iov_len, 100);
   CHECK_PTR(vector[0].iov_base, first);
 
-  second = iovec_increase(&entries, &vector, 50);
+  second = iovec_new_chunk(&entries, &vector, 50);
   CHECK(second != NULL);
   CHECK_INT(entries, 2);
   CHECK_INT(vector[1].iov_len, 50);
@@ -38,8 +38,8 @@ static void case_free_resets(void) {
   struct iovec *vector  = NULL;
 
   test_case("free releases the entries and resets the vector");
-  CHECK(iovec_increase(&entries, &vector, 10) != NULL);
-  CHECK(iovec_increase(&entries, &vector, 10) != NULL);
+  CHECK(iovec_new_chunk(&entries, &vector, 10) != NULL);
+  CHECK(iovec_new_chunk(&entries, &vector, 10) != NULL);
   iovec_free(&entries, &vector);
   CHECK_INT(entries, 0);
   CHECK_PTR(vector, NULL);
@@ -52,12 +52,12 @@ static void case_fixlast_shrinks(void) {
   char         *block;
 
   test_case("fixlast trims the last entry to the bytes actually used");
-  CHECK(iovec_increase(&entries, &vector, 64) != NULL);
-  block = iovec_increase(&entries, &vector, 1000);
+  CHECK(iovec_new_chunk(&entries, &vector, 64) != NULL);
+  block = iovec_new_chunk(&entries, &vector, 1000);
   CHECK(block != NULL);
   memset(block, 'x', 20);
 
-  iovec_fixlast(&entries, &vector, block + 20);
+  iovec_trim_last(&entries, &vector, block + 20);
   CHECK_INT(entries, 2);
   CHECK_INT(vector[1].iov_len, 20);
   CHECK_INT(iovec_length(&entries, (const struct iovec **)&vector), 84);
@@ -71,7 +71,7 @@ static void case_fixlast_on_empty(void) {
   struct iovec *vector  = NULL;
 
   test_case("fixlast on an empty vector does nothing");
-  iovec_fixlast(&entries, &vector, NULL);
+  iovec_trim_last(&entries, &vector, NULL);
   CHECK_INT(entries, 0);
   CHECK_PTR(vector, NULL);
 }
@@ -103,9 +103,9 @@ static void case_fix_increase(void) {
   char         *block;
 
   test_case("fix_increase trims the previous entry and adds a new one");
-  block = iovec_increase(&entries, &vector, 500);
+  block = iovec_new_chunk(&entries, &vector, 500);
   CHECK(block != NULL);
-  block = iovec_fix_increase_or_free(&entries, &vector, block + 30, 200);
+  block = iovec_next_chunk(&entries, &vector, block + 30, 200);
   CHECK(block != NULL);
   CHECK_INT(entries, 2);
   CHECK_INT(vector[0].iov_len, 30);
diff --git a/tests/t_scan_urlencoded_query.c b/tests/t_urlencoded.c
index f660ea3..1239e6b 100644
--- a/tests/t_scan_urlencoded_query.c
+++ b/tests/t_urlencoded.c
@@ -7,7 +7,7 @@
 #include <string.h>
 
 /* Opentracker */
-#include "scan_urlencoded_query.h"
+#include "ot_urlencoded.h"
 #include "test.h"
 
 /* The scanner returns the number of bytes written to the destination, or
@@ -23,7 +23,7 @@ static void case_path(void) {
   ssize_t n;
 
   test_case("path stops at the question mark");
-  n = scan_urlencoded_query(&p, dest, SCAN_PATH);
+  n = urlencoded_parse(&p, dest, SCAN_PATH);
   CHECK_INT(n, 9);
   dest[n] = 0;
   CHECK_STR(dest, "/announce");
@@ -37,22 +37,22 @@ static void case_param_and_value(void) {
   ssize_t n;
 
   test_case("parameter stops at '=', value stops at '&'");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_PARAM);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_PARAM);
   CHECK_INT(n, 9);
   dest[n] = 0;
   CHECK_STR(dest, "info_hash");
 
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, 3);
   dest[n] = 0;
   CHECK_STR(dest, "abc");
 
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_PARAM);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_PARAM);
   CHECK_INT(n, 4);
   dest[n] = 0;
   CHECK_STR(dest, "port");
 
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, 2);
   dest[n] = 0;
   CHECK_STR(dest, "80");
@@ -65,7 +65,7 @@ static void case_percent_decoding(void) {
   ssize_t n;
 
   test_case("percent escapes decode");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, 3);
   CHECK_MEM(dest, "ABC", 3);
 }
@@ -79,7 +79,7 @@ static void case_binary_info_hash(void) {
   ssize_t       n;
 
   test_case("twenty byte binary value survives decoding");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, 20);
   CHECK_MEM(dest, want, 20);
 }
@@ -90,7 +90,7 @@ static void case_in_place(void) {
   ssize_t n;
 
   test_case("decoding in place over the source is safe");
-  n = scan_urlencoded_query(&p, query, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, query, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, 2);
   CHECK_MEM(query, "AB", 2);
 }
@@ -102,7 +102,7 @@ static void case_bad_escape(void) {
   ssize_t n;
 
   test_case("a non hexadecimal escape is a parse error");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, -1);
 }
 
@@ -113,7 +113,7 @@ static void case_truncated_escape(void) {
   ssize_t n;
 
   test_case("an escape cut short by the terminator is a parse error");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, -1);
 }
 
@@ -125,11 +125,11 @@ static void case_terminator(void) {
   ssize_t n;
 
   test_case("a hard terminator before any output reports end of input");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_PARAM);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_PARAM);
   CHECK_INT(n, -2);
 
   p = space;
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_PARAM);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_PARAM);
   CHECK_INT(n, -2);
 }
 
@@ -140,10 +140,10 @@ static void case_terminator_after_output(void) {
   ssize_t n;
 
   test_case("a hard terminator after output is left for the next call");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, 3);
   CHECK_INT(*p, 0);
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, -2);
 }
 
@@ -159,14 +159,14 @@ static void case_separators_are_contextual(void) {
   ssize_t n;
 
   test_case("a question mark is literal inside a value");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, 3);
   dest[n] = 0;
   CHECK_STR(dest, "a?b");
 
   test_case("an equals sign is literal inside a value");
   p = equals;
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, 3);
   dest[n] = 0;
   CHECK_STR(dest, "a=b");
@@ -179,7 +179,7 @@ static void case_ampersand_in_path(void) {
   ssize_t n;
 
   test_case("an ampersand in a path is a parse error");
-  n = scan_urlencoded_query(&p, dest, SCAN_PATH);
+  n = urlencoded_parse(&p, dest, SCAN_PATH);
   CHECK_INT(n, -1);
 }
 
@@ -190,7 +190,7 @@ static void case_raw_high_byte(void) {
   ssize_t n;
 
   test_case("an undecoded byte above ASCII is a parse error");
-  n = scan_urlencoded_query(&p, dest, SCAN_SEARCHPATH_VALUE);
+  n = urlencoded_parse(&p, dest, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(n, -1);
 }
 
@@ -200,12 +200,12 @@ static void case_skipvalue(void) {
   char *p       = query;
 
   test_case("skipvalue steps over the value and its separator");
-  scan_urlencoded_skipvalue(&p);
+  urlencoded_skip_value(&p);
   CHECK_STR(p, "next=1");
 
   test_case("skipvalue leaves a hard terminator in place");
   p = bare;
-  scan_urlencoded_skipvalue(&p);
+  urlencoded_skip_value(&p);
   CHECK_INT(*p, 0);
 }
 
@@ -217,15 +217,15 @@ static void case_find_keywords(void) {
   char                    *p          = match;
 
   test_case("a known keyword returns its value");
-  CHECK_INT(scan_find_keywords(keywords, &p, SCAN_SEARCHPATH_PARAM), 2);
+  CHECK_INT(urlencoded_match_keyword(keywords, &p, SCAN_SEARCHPATH_PARAM), 2);
 
   test_case("an unknown keyword returns -3");
   p = nomatch;
-  CHECK_INT(scan_find_keywords(keywords, &p, SCAN_SEARCHPATH_PARAM), -3);
+  CHECK_INT(urlencoded_match_keyword(keywords, &p, SCAN_SEARCHPATH_PARAM), -3);
 
   test_case("a prefix of a keyword does not match it");
   p = prefix;
-  CHECK_INT(scan_find_keywords(keywords, &p, SCAN_SEARCHPATH_PARAM), -3);
+  CHECK_INT(urlencoded_match_keyword(keywords, &p, SCAN_SEARCHPATH_PARAM), -3);
 }
 
 static void case_fixed_int(void) {
@@ -265,7 +265,7 @@ static void case_fmt_passes_safe_bytes(void) {
   size_t        n;
 
   test_case("alphanumerics and the safe punctuation pass through");
-  n       = fmt_urlencoded(dest, src, 11);
+  n       = urlencoded_format(dest, src, 11);
   dest[n] = 0;
   CHECK_INT(n, 11);
   CHECK_STR(dest, "aZ09$-./=_~");
@@ -277,7 +277,7 @@ static void case_fmt_escapes_the_rest(void) {
   size_t        n;
 
   test_case("everything else becomes a percent escape");
-  n       = fmt_urlencoded(dest, src, sizeof(src));
+  n       = urlencoded_format(dest, src, sizeof(src));
   dest[n] = 0;
   CHECK_INT(n, 18);
   CHECK_STR(dest, "%20%25%26%2b%3a%3f");
@@ -289,7 +289,7 @@ static void case_fmt_hex_is_lower_case(void) {
   size_t        n;
 
   test_case("escapes use lower case hex digits");
-  n       = fmt_urlencoded(dest, src, sizeof(src));
+  n       = urlencoded_format(dest, src, sizeof(src));
   dest[n] = 0;
   CHECK_INT(n, 9);
   CHECK_STR(dest, "%00%ab%ff");
@@ -300,7 +300,7 @@ static void case_fmt_zero_length(void) {
 
   test_case("a zero length input writes nothing");
   memset(dest, 0x5a, sizeof(dest));
-  CHECK_INT(fmt_urlencoded(dest, (const uint8_t *)"abc", 0), 0);
+  CHECK_INT(urlencoded_format(dest, (const uint8_t *)"abc", 0), 0);
   CHECK_MEM(dest, "\x5a\x5a\x5a\x5a", 4);
 }
 
@@ -312,7 +312,7 @@ static void case_fmt_worst_case_fits(void) {
   test_case("a hash of entirely unsafe bytes needs three times its length");
   for (i = 0; i < sizeof(src); ++i)
     src[i] = 0xff;
-  n       = fmt_urlencoded(dest, src, sizeof(src));
+  n       = urlencoded_format(dest, src, sizeof(src));
   dest[n] = 0;
   CHECK_INT(n, 60);
   for (i = 0; i < 20; ++i)
@@ -328,7 +328,7 @@ static void case_fmt_decoder_disagrees_on_dollar(void) {
      encoder passes through unescaped, '$' is the only one the decoder then
      refuses, and it refuses the whole string rather than stopping short.
      Output of the urlencoded full scrape therefore does not round trip
-     through scan_urlencoded_query when a hash contains 0x24. Harmless today
+     through urlencoded_parse when a hash contains 0x24. Harmless today
      because only third party tooling reads that output. */
   const uint8_t src[]  = {'a', '$', 'b'};
   char          dest[16];
@@ -338,15 +338,15 @@ static void case_fmt_decoder_disagrees_on_dollar(void) {
   ssize_t       got;
 
   test_case("the encoder passes '$' but the decoder rejects it");
-  n       = fmt_urlencoded(dest, src, sizeof(src));
+  n       = urlencoded_format(dest, src, sizeof(src));
   dest[n] = 0;
   CHECK_STR(dest, "a$b");
 
-  got = scan_urlencoded_query(&p, scanned, SCAN_SEARCHPATH_VALUE);
+  got = urlencoded_parse(&p, scanned, SCAN_SEARCHPATH_VALUE);
   CHECK_INT(got, -1);
 }
 
-void test_scan_urlencoded_query(void) {
+void test_urlencoded(void) {
   case_path();
   case_param_and_value();
   case_percent_decoding();
diff --git a/tests/t_vector.c b/tests/t_vector.c
index a8186b2..541a6da 100644
--- a/tests/t_vector.c
+++ b/tests/t_vector.c
@@ -13,7 +13,7 @@
 #include "trackerlogic.h"
 #include "test.h"
 
-/* binary_search returns the matching member when there is one, and otherwise
+/* vector_binary_search returns the matching member when there is one, and otherwise
    the position at which the key would have to be inserted to keep the vector
    sorted. exactmatch distinguishes the two. */
 
@@ -25,7 +25,7 @@ static void                case_search_finds_member(void) {
   void               *found;
 
   test_case("an existing key is found");
-  found = binary_search(key, sorted, 5, 4, 4, &exactmatch);
+  found = vector_binary_search(key, sorted, 5, 4, 4, &exactmatch);
   CHECK(exactmatch != 0);
   CHECK_PTR(found, sorted[2]);
 }
@@ -36,9 +36,9 @@ static void case_search_finds_first_and_last(void) {
   int                 exactmatch;
 
   test_case("the first and last members are found");
-  CHECK_PTR(binary_search(first, sorted, 5, 4, 4, &exactmatch), sorted[0]);
+  CHECK_PTR(vector_binary_search(first, sorted, 5, 4, 4, &exactmatch), sorted[0]);
   CHECK(exactmatch != 0);
-  CHECK_PTR(binary_search(last, sorted, 5, 4, 4, &exactmatch), sorted[4]);
+  CHECK_PTR(vector_binary_search(last, sorted, 5, 4, 4, &exactmatch), sorted[4]);
   CHECK(exactmatch != 0);
 }
 
@@ -49,11 +49,11 @@ static void case_search_insert_position(void) {
   void               *slot;
 
   test_case("a missing key yields its insert position");
-  slot = binary_search(middle, sorted, 5, 4, 4, &exactmatch);
+  slot = vector_binary_search(middle, sorted, 5, 4, 4, &exactmatch);
   CHECK_INT(exactmatch, 0);
   CHECK_PTR(slot, sorted[2]);
 
-  slot = binary_search(before, sorted, 5, 4, 4, &exactmatch);
+  slot = vector_binary_search(before, sorted, 5, 4, 4, &exactmatch);
   CHECK_INT(exactmatch, 0);
   CHECK_PTR(slot, sorted[0]);
 }
@@ -64,7 +64,7 @@ static void case_search_past_the_end(void) {
   void               *slot;
 
   test_case("a key above every member yields the position past the end");
-  slot = binary_search(beyond, sorted, 5, 4, 4, &exactmatch);
+  slot = vector_binary_search(beyond, sorted, 5, 4, 4, &exactmatch);
   CHECK_INT(exactmatch, 0);
   CHECK_PTR(slot, sorted[5]);
 }
@@ -74,7 +74,7 @@ static void case_search_empty(void) {
   void *base = (void *)sorted;
 
   test_case("searching an empty vector reports no match at the base");
-  CHECK_PTR(binary_search(sorted[0], base, 0, 4, 4, &exactmatch), base);
+  CHECK_PTR(vector_binary_search(sorted[0], base, 0, 4, 4, &exactmatch), base);
   CHECK_INT(exactmatch, 0);
 }
 
diff --git a/tests/test.h b/tests/test.h
index fd574c2..cebd08a 100644
--- a/tests/test.h
+++ b/tests/test.h
@@ -76,7 +76,7 @@ extern unsigned long test_failures;
   } while (0)
 
 /* One entry point per module under test */
-void test_scan_urlencoded_query(void);
+void test_urlencoded(void);
 void test_iovec(void);
 void test_vector(void);
 void test_random(void);
@@ -88,5 +88,6 @@ void test_ip(void);
 void test_socket(void);
 void test_mutex(void);
 void test_batch(void);
+void test_fdstate(void);
 
 #endif