diff --git a/src/test/test.c b/src/test/test.c
index 31224ca3ab..220484a296 100644
--- a/src/test/test.c
+++ b/src/test/test.c
@@ -232,7 +232,7 @@ free_pregenerated_keys(void)
 
 /** Run unit tests for the onion handshake code. */
 static void
-test_onion_handshake(void)
+test_onion_handshake(void *arg)
 {
   /* client-side */
   crypto_dh_t *c_dh = NULL;
@@ -245,6 +245,7 @@ test_onion_handshake(void)
   /* shared */
   crypto_pk_t *pk = NULL, *pk2 = NULL;
 
+  (void)arg;
   pk = pk_generate(0);
   pk2 = pk_generate(1);
 
@@ -420,7 +421,7 @@ test_ntor_handshake(void *arg)
 
 /** Run unit tests for the onion queues. */
 static void
-test_onion_queues(void)
+test_onion_queues(void *arg)
 {
   uint8_t buf1[TAP_ONIONSKIN_CHALLENGE_LEN] = {0};
   uint8_t buf2[NTOR_ONIONSKIN_LEN] = {0};
@@ -431,6 +432,7 @@ test_onion_queues(void)
   create_cell_t *onionskin = NULL, *create2_ptr;
   create_cell_t *create1 = tor_malloc_zero(sizeof(create_cell_t));
   create_cell_t *create2 = tor_malloc_zero(sizeof(create_cell_t));
+  (void)arg;
   create2_ptr = create2; /* remember, but do not free */
 
   create_cell_init(create1, CELL_CREATE, ONION_HANDSHAKE_TYPE_TAP,
@@ -466,7 +468,7 @@ test_onion_queues(void)
 }
 
 static void
-test_circuit_timeout(void)
+test_circuit_timeout(void *arg)
 {
   /* Plan:
    *  1. Generate 1000 samples
@@ -484,6 +486,7 @@ test_circuit_timeout(void)
   or_state_t *state=NULL;
   int i, runs;
   double close_ms;
+  (void)arg;
   circuit_build_times_init(&initial);
   circuit_build_times_init(&estimate);
   circuit_build_times_init(&final);
@@ -619,7 +622,7 @@ test_circuit_timeout(void)
 
 /** Test encoding and parsing of rendezvous service descriptors. */
 static void
-test_rend_fns(void)
+test_rend_fns(void *arg)
 {
   rend_service_descriptor_t *generated = NULL, *parsed = NULL;
   char service_id[DIGEST_LEN];
@@ -642,6 +645,7 @@ test_rend_fns(void)
   char address6[] = "foo.bar.abcdefghijklmnop.onion";
   char address7[] = ".abcdefghijklmnop.onion";
 
+  (void)arg;
   tt_assert(BAD_HOSTNAME == parse_extended_hostname(address1));
   tt_assert(ONION_HOSTNAME == parse_extended_hostname(address2));
   tt_str_op(address2,==, "aaaaaaaaaaaaaaaa");
@@ -771,7 +775,7 @@ test_rend_fns(void)
 
 /** Run unit tests for GeoIP code. */
 static void
-test_geoip(void)
+test_geoip(void *arg)
 {
   int i, j;
   time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */
@@ -825,6 +829,7 @@ test_geoip(void)
   /* Populate the DB a bit.  Add these in order, since we can't do the final
    * 'sort' step.  These aren't very good IP addresses, but they're perfectly
    * fine uint32_t values. */
+  (void)arg;
   tt_int_op(0,==, geoip_parse_entry("10,50,AB", AF_INET));
   tt_int_op(0,==, geoip_parse_entry("52,90,XY", AF_INET));
   tt_int_op(0,==, geoip_parse_entry("95,100,AB", AF_INET));
@@ -1017,7 +1022,7 @@ test_geoip(void)
 }
 
 static void
-test_geoip_with_pt(void)
+test_geoip_with_pt(void *arg)
 {
   time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */
   char *s = NULL;
@@ -1025,6 +1030,7 @@ test_geoip_with_pt(void)
   tor_addr_t addr;
   struct in6_addr in6;
 
+  (void)arg;
   get_options_mutable()->BridgeRelay = 1;
   get_options_mutable()->BridgeRecordUsageByCountry = 1;
 
@@ -1093,7 +1099,7 @@ test_geoip_with_pt(void)
 
 /** Run unit tests for stats code. */
 static void
-test_stats(void)
+test_stats(void *arg)
 {
   time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */
   char *s = NULL;
@@ -1101,6 +1107,7 @@ test_stats(void)
 
   /* Start with testing exit port statistics; we shouldn't collect exit
    * stats without initializing them. */
+  (void)arg;
   rep_hist_note_exit_stream_opened(80);
   rep_hist_note_exit_bytes(80, 100, 10000);
   s = rep_hist_format_exit_stats(now + 86400);
@@ -1250,35 +1257,10 @@ test_stats(void)
   tor_free(s);
 }
 
-static void *
-legacy_test_setup(const struct testcase_t *testcase)
-{
-  return testcase->setup_data;
-}
-
-void
-legacy_test_helper(void *data)
-{
-  void (*fn)(void) = data;
-  fn();
-}
-
-static int
-legacy_test_cleanup(const struct testcase_t *testcase, void *ptr)
-{
-  (void)ptr;
-  (void)testcase;
-  return 1;
-}
-
-const struct testcase_setup_t legacy_setup = {
-  legacy_test_setup, legacy_test_cleanup
-};
-
 #define ENT(name)                                                       \
-  { #name, legacy_test_helper, 0, &legacy_setup, test_ ## name }
+  { #name, test_ ## name , 0, NULL, NULL }
 #define FORK(name)                                                      \
-  { #name, legacy_test_helper, TT_FORK, &legacy_setup, test_ ## name }
+  { #name, test_ ## name , TT_FORK, NULL, NULL }
 
 static struct testcase_t test_array[] = {
   ENT(onion_handshake),
diff --git a/src/test/test.h b/src/test/test.h
index c2b333c286..8eb2dfc016 100644
--- a/src/test/test.h
+++ b/src/test/test.h
@@ -66,9 +66,6 @@
 const char *get_fname(const char *name);
 crypto_pk_t *pk_generate(int idx);
 
-void legacy_test_helper(void *data);
-extern const struct testcase_setup_t legacy_setup;
-
 #define US2_CONCAT_2__(a, b) a ## __ ## b
 #define US_CONCAT_2__(a, b) a ## _ ## b
 #define US_CONCAT_3__(a, b, c) a ## _ ## b ## _ ## c
diff --git a/src/test/test_addr.c b/src/test/test_addr.c
index d319440ef6..28860f6a49 100644
--- a/src/test/test_addr.c
+++ b/src/test/test_addr.c
@@ -10,13 +10,14 @@
 #include "addressmap.h"
 
 static void
-test_addr_basic(void)
+test_addr_basic(void *arg)
 {
   uint32_t u32;
   uint16_t u16;
   char *cp;
 
   /* Test addr_port_lookup */
+  (void)arg;
   cp = NULL; u32 = 3; u16 = 3;
   tt_assert(!addr_port_lookup(LOG_WARN, "1.2.3.4", &cp, &u32, &u16));
   tt_str_op(cp,==, "1.2.3.4");
@@ -179,7 +180,7 @@ test_addr_basic(void)
 
 /** Run unit tests for IPv6 encoding/decoding/manipulation functions. */
 static void
-test_addr_ip6_helpers(void)
+test_addr_ip6_helpers(void *arg)
 {
   char buf[TOR_ADDR_BUF_LEN], bug[TOR_ADDR_BUF_LEN];
   char rbuf[REVERSE_LOOKUP_NAME_BUF_LEN];
@@ -194,6 +195,7 @@ test_addr_ip6_helpers(void)
   struct sockaddr_in6 *sin6;
 
   /* Test tor_inet_ntop and tor_inet_pton: IPv6 */
+  (void)arg;
   {
     const char *ip = "2001::1234";
     const char *ip_ffff = "::ffff:192.168.1.2";
@@ -736,7 +738,7 @@ test_addr_ip6_helpers(void)
 
 /** Test tor_addr_port_parse(). */
 static void
-test_addr_parse(void)
+test_addr_parse(void *arg)
 {
   int r;
   tor_addr_t addr;
@@ -744,6 +746,7 @@ test_addr_parse(void)
   uint16_t port = 0;
 
   /* Correct call. */
+  (void)arg;
   r= tor_addr_port_parse(LOG_DEBUG,
                          "192.0.2.1:1234",
                          &addr, &port, -1);
@@ -1047,7 +1050,7 @@ test_addr_make_null(void *data)
 }
 
 #define ADDR_LEGACY(name)                                               \
-  { #name, legacy_test_helper, 0, &legacy_setup, test_addr_ ## name }
+  { #name, test_addr_ ## name , 0, NULL, NULL }
 
 struct testcase_t addr_tests[] = {
   ADDR_LEGACY(basic),
diff --git a/src/test/test_containers.c b/src/test/test_containers.c
index 506d2130ca..21811b9776 100644
--- a/src/test/test_containers.c
+++ b/src/test/test_containers.c
@@ -37,7 +37,7 @@ compare_without_first_ch_(const void *a, const void **b)
 
 /** Run unit tests for basic dynamic-sized array functionality. */
 static void
-test_container_smartlist_basic(void)
+test_container_smartlist_basic(void *arg)
 {
   smartlist_t *sl;
   char *v0 = tor_strdup("v0");
@@ -52,6 +52,7 @@ test_container_smartlist_basic(void)
   /* XXXX test sort_digests, uniq_strings, uniq_digests */
 
   /* Test smartlist add, del_keeporder, insert, get. */
+  (void)arg;
   sl = smartlist_new();
   smartlist_add(sl, v1);
   smartlist_add(sl, v2);
@@ -92,13 +93,14 @@ test_container_smartlist_basic(void)
 
 /** Run unit tests for smartlist-of-strings functionality. */
 static void
-test_container_smartlist_strings(void)
+test_container_smartlist_strings(void *arg)
 {
   smartlist_t *sl = smartlist_new();
   char *cp=NULL, *cp_alloc=NULL;
   size_t sz;
 
   /* Test split and join */
+  (void)arg;
   tt_int_op(0,==, smartlist_len(sl));
   smartlist_split_string(sl, "abc", ":", 0, 0);
   tt_int_op(1,==, smartlist_len(sl));
@@ -349,7 +351,7 @@ test_container_smartlist_strings(void)
 
 /** Run unit tests for smartlist set manipulation functions. */
 static void
-test_container_smartlist_overlap(void)
+test_container_smartlist_overlap(void *arg)
 {
   smartlist_t *sl = smartlist_new();
   smartlist_t *ints = smartlist_new();
@@ -357,6 +359,7 @@ test_container_smartlist_overlap(void)
   smartlist_t *evens = smartlist_new();
   smartlist_t *primes = smartlist_new();
   int i;
+  (void)arg;
   for (i=1; i < 10; i += 2)
     smartlist_add(odds, (void*)(uintptr_t)i);
   for (i=0; i < 10; i += 2)
@@ -402,11 +405,12 @@ test_container_smartlist_overlap(void)
 
 /** Run unit tests for smartlist-of-digests functions. */
 static void
-test_container_smartlist_digests(void)
+test_container_smartlist_digests(void *arg)
 {
   smartlist_t *sl = smartlist_new();
 
   /* contains_digest */
+  (void)arg;
   smartlist_add(sl, tor_memdup("AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN));
   smartlist_add(sl, tor_memdup("\00090AAB2AAAAaasdAAAAA", DIGEST_LEN));
   smartlist_add(sl, tor_memdup("\00090AAB2AAAAaasdAAAAA", DIGEST_LEN));
@@ -435,13 +439,14 @@ test_container_smartlist_digests(void)
 
 /** Run unit tests for concatenate-a-smartlist-of-strings functions. */
 static void
-test_container_smartlist_join(void)
+test_container_smartlist_join(void *arg)
 {
   smartlist_t *sl = smartlist_new();
   smartlist_t *sl2 = smartlist_new(), *sl3 = smartlist_new(),
     *sl4 = smartlist_new();
   char *joined=NULL;
   /* unique, sorted. */
+  (void)arg;
   smartlist_split_string(sl,
                          "Abashments Ambush Anchorman Bacon Banks Borscht "
                          "Bunks Inhumane Insurance Knish Know Manners "
@@ -532,11 +537,12 @@ test_container_smartlist_ints_eq(void *arg)
 
 /** Run unit tests for bitarray code */
 static void
-test_container_bitarray(void)
+test_container_bitarray(void *arg)
 {
   bitarray_t *ba = NULL;
   int i, j, ok=1;
 
+  (void)arg;
   ba = bitarray_init_zero(1);
   tt_assert(ba);
   tt_assert(! bitarray_is_set(ba, 0));
@@ -575,7 +581,7 @@ test_container_bitarray(void)
 /** Run unit tests for digest set code (implemented as a hashtable or as a
  * bloom filter) */
 static void
-test_container_digestset(void)
+test_container_digestset(void *arg)
 {
   smartlist_t *included = smartlist_new();
   char d[DIGEST_LEN];
@@ -584,6 +590,7 @@ test_container_digestset(void)
   int false_positives = 0;
   digestset_t *set = NULL;
 
+  (void)arg;
   for (i = 0; i < 1000; ++i) {
     crypto_rand(d, DIGEST_LEN);
     smartlist_add(included, tor_memdup(d, DIGEST_LEN));
@@ -628,7 +635,7 @@ compare_strings_for_pqueue_(const void *p1, const void *p2)
 
 /** Run unit tests for heap-based priority queue functions. */
 static void
-test_container_pqueue(void)
+test_container_pqueue(void *arg)
 {
   smartlist_t *sl = smartlist_new();
   int (*cmp)(const void *, const void*);
@@ -650,6 +657,8 @@ test_container_pqueue(void)
 
 #define OK() smartlist_pqueue_assert_ok(sl, cmp, offset)
 
+  (void)arg;
+
   cmp = compare_strings_for_pqueue_;
   smartlist_pqueue_add(sl, cmp, offset, &cows);
   smartlist_pqueue_add(sl, cmp, offset, &zebras);
@@ -725,7 +734,7 @@ test_container_pqueue(void)
 
 /** Run unit tests for string-to-void* map functions */
 static void
-test_container_strmap(void)
+test_container_strmap(void *arg)
 {
   strmap_t *map;
   strmap_iter_t *iter;
@@ -742,6 +751,7 @@ test_container_strmap(void)
   char *v104 = tor_strdup("v104");
   char *v105 = tor_strdup("v105");
 
+  (void)arg;
   map = strmap_new();
   tt_assert(map);
   tt_int_op(strmap_size(map),==, 0);
@@ -832,7 +842,7 @@ test_container_strmap(void)
 
 /** Run unit tests for getting the median of a list. */
 static void
-test_container_order_functions(void)
+test_container_order_functions(void *arg)
 {
   int lst[25], n = 0;
   unsigned int lst2[25];
@@ -840,6 +850,7 @@ test_container_order_functions(void)
 
 #define median() median_int(lst, n)
 
+  (void)arg;
   lst[n++] = 12;
   tt_int_op(12,==, median()); /* 12 */
   lst[n++] = 77;
@@ -929,7 +940,7 @@ test_container_di_map(void *arg)
 
 /** Run unit tests for fp_pair-to-void* map functions */
 static void
-test_container_fp_pair_map(void)
+test_container_fp_pair_map(void *arg)
 {
   fp_pair_map_t *map;
   fp_pair_t fp1, fp2, fp3, fp4, fp5, fp6;
@@ -944,6 +955,7 @@ test_container_fp_pair_map(void)
   char *v104 = tor_strdup("v104");
   char *v105 = tor_strdup("v105");
 
+  (void)arg;
   map = fp_pair_map_new();
   tt_assert(map);
   tt_int_op(fp_pair_map_size(map),==, 0);
@@ -1024,7 +1036,7 @@ test_container_fp_pair_map(void)
 }
 
 #define CONTAINER_LEGACY(name)                                          \
-  { #name, legacy_test_helper, 0, &legacy_setup, test_container_ ## name }
+  { #name, test_container_ ## name , 0, NULL, NULL }
 
 #define CONTAINER(name, flags)                                          \
   { #name, test_container_ ## name, (flags), NULL, NULL }
diff --git a/src/test/test_crypto.c b/src/test/test_crypto.c
index 86ed86f76d..c765b2950c 100644
--- a/src/test/test_crypto.c
+++ b/src/test/test_crypto.c
@@ -20,7 +20,7 @@ extern const char AUTHORITY_SIGNKEY_A_DIGEST256[];
 
 /** Run unit tests for Diffie-Hellman functionality. */
 static void
-test_crypto_dh(void)
+test_crypto_dh(void *arg)
 {
   crypto_dh_t *dh1 = crypto_dh_new(DH_TYPE_CIRCUIT);
   crypto_dh_t *dh2 = crypto_dh_new(DH_TYPE_CIRCUIT);
@@ -30,6 +30,7 @@ test_crypto_dh(void)
   char s2[DH_BYTES];
   ssize_t s1len, s2len;
 
+  (void)arg;
   tt_int_op(crypto_dh_get_bytes(dh1),==, DH_BYTES);
   tt_int_op(crypto_dh_get_bytes(dh2),==, DH_BYTES);
 
@@ -63,13 +64,14 @@ test_crypto_dh(void)
 /** Run unit tests for our random number generation function and its wrappers.
  */
 static void
-test_crypto_rng(void)
+test_crypto_rng(void *arg)
 {
   int i, j, allok;
   char data1[100], data2[100];
   double d;
 
   /* Try out RNG. */
+  (void)arg;
   tt_assert(! crypto_seed_rng(0));
   crypto_rand(data1, 100);
   crypto_rand(data2, 100);
@@ -252,7 +254,7 @@ test_crypto_aes(void *arg)
 
 /** Run unit tests for our SHA-1 functionality */
 static void
-test_crypto_sha(void)
+test_crypto_sha(void *arg)
 {
   crypto_digest_t *d1 = NULL, *d2 = NULL;
   int i;
@@ -263,6 +265,7 @@ test_crypto_sha(void)
   char *mem_op_hex_tmp=NULL;
 
   /* Test SHA-1 with a test vector from the specification. */
+  (void)arg;
   i = crypto_digest(data, "abc", 3);
   test_memeq_hex(data, "A9993E364706816ABA3E25717850C26C9CD0D89D");
   tt_int_op(i, ==, 0);
@@ -392,7 +395,7 @@ test_crypto_sha(void)
 
 /** Run unit tests for our public key crypto functions */
 static void
-test_crypto_pk(void)
+test_crypto_pk(void *arg)
 {
   crypto_pk_t *pk1 = NULL, *pk2 = NULL;
   char *encoded = NULL;
@@ -401,6 +404,7 @@ test_crypto_pk(void)
   int i, len;
 
   /* Public-key ciphers */
+  (void)arg;
   pk1 = pk_generate(0);
   pk2 = crypto_pk_new();
   tt_assert(pk1 && pk2);
@@ -561,13 +565,14 @@ test_crypto_pk_fingerprints(void *arg)
 
 /** Sanity check for crypto pk digests  */
 static void
-test_crypto_digests(void)
+test_crypto_digests(void *arg)
 {
   crypto_pk_t *k = NULL;
   ssize_t r;
   digests_t pkey_digests;
   char digest[DIGEST_LEN];
 
+  (void)arg;
   k = crypto_pk_new();
   tt_assert(k);
   r = crypto_pk_read_private_key_from_string(k, AUTHORITY_SIGNKEY_3, -1);
@@ -591,11 +596,12 @@ test_crypto_digests(void)
 /** Run unit tests for misc crypto formatting functionality (base64, base32,
  * fingerprints, etc) */
 static void
-test_crypto_formats(void)
+test_crypto_formats(void *arg)
 {
   char *data1 = NULL, *data2 = NULL, *data3 = NULL;
   int i, j, idx;
 
+  (void)arg;
   data1 = tor_malloc(1024);
   data2 = tor_malloc(1024);
   data3 = tor_malloc(1024);
@@ -696,13 +702,14 @@ test_crypto_formats(void)
 
 /** Run unit tests for our secret-to-key passphrase hashing functionality. */
 static void
-test_crypto_s2k(void)
+test_crypto_s2k(void *arg)
 {
   char buf[29];
   char buf2[29];
   char *buf3 = NULL;
   int i;
 
+  (void)arg;
   memset(buf, 0, sizeof(buf));
   memset(buf2, 0, sizeof(buf2));
   buf3 = tor_malloc(65536);
@@ -842,10 +849,11 @@ test_crypto_aes_iv(void *arg)
 
 /** Test base32 decoding. */
 static void
-test_crypto_base32_decode(void)
+test_crypto_base32_decode(void *arg)
 {
   char plain[60], encoded[96 + 1], decoded[60];
   int res;
+  (void)arg;
   crypto_rand(plain, 60);
   /* Encode and decode a random string. */
   base32_encode(encoded, 96 + 1, plain, 60);
@@ -1276,7 +1284,7 @@ static const struct testcase_setup_t pass_data = {
 };
 
 #define CRYPTO_LEGACY(name)                                            \
-  { #name, legacy_test_helper, 0, &legacy_setup, test_crypto_ ## name }
+  { #name, test_crypto_ ## name , 0, NULL, NULL }
 
 struct testcase_t crypto_tests[] = {
   CRYPTO_LEGACY(formats),
diff --git a/src/test/test_dir.c b/src/test/test_dir.c
index e3af699c23..61dac5d331 100644
--- a/src/test/test_dir.c
+++ b/src/test/test_dir.c
@@ -25,8 +25,9 @@
 #include "test.h"
 
 static void
-test_dir_nicknames(void)
+test_dir_nicknames(void *arg)
 {
+  (void)arg;
   tt_assert( is_legal_nickname("a"));
   tt_assert(!is_legal_nickname(""));
   tt_assert(!is_legal_nickname("abcdefghijklmnopqrst")); /* 20 chars */
@@ -73,7 +74,7 @@ test_dir_nicknames(void)
 
 /** Run unit tests for router descriptor generation logic. */
 static void
-test_dir_formats(void)
+test_dir_formats(void *arg)
 {
   char *buf = NULL;
   char buf2[8192];
@@ -89,6 +90,7 @@ test_dir_formats(void)
   or_options_t *options = get_options_mutable();
   const addr_policy_t *p;
 
+  (void)arg;
   pk1 = pk_generate(0);
   pk2 = pk_generate(1);
 
@@ -293,11 +295,12 @@ test_dir_formats(void)
 }
 
 static void
-test_dir_versions(void)
+test_dir_versions(void *arg)
 {
   tor_version_t ver1;
 
   /* Try out version parsing functionality */
+  (void)arg;
   tt_int_op(0,==, tor_version_parse("0.3.4pre2-cvs", &ver1));
   tt_int_op(0,==, ver1.major);
   tt_int_op(3,==, ver1.minor);
@@ -410,11 +413,12 @@ test_dir_versions(void)
 
 /** Run unit tests for directory fp_pair functions. */
 static void
-test_dir_fp_pairs(void)
+test_dir_fp_pairs(void *arg)
 {
   smartlist_t *sl = smartlist_new();
   fp_pair_t *pair;
 
+  (void)arg;
   dir_split_resource_into_fingerprint_pairs(
        /* Two pairs, out of order, with one duplicate. */
        "73656372657420646174612E0000000000FFFFFF-"
@@ -557,7 +561,7 @@ test_dir_split_fps(void *testdata)
 }
 
 static void
-test_dir_measured_bw_kb(void)
+test_dir_measured_bw_kb(void *arg)
 {
   measured_bw_line_t mbwl;
   int i;
@@ -605,6 +609,7 @@ test_dir_measured_bw_kb(void)
     "end"
   };
 
+  (void)arg;
   for (i = 0; strcmp(lines_fail[i], "end"); i++) {
     //fprintf(stderr, "Testing: %s\n", lines_fail[i]);
     tt_assert(measured_bw_line_parse(&mbwl, lines_fail[i]) == -1);
@@ -626,7 +631,7 @@ test_dir_measured_bw_kb(void)
 
 /** Do the measured bandwidth cache unit test */
 static void
-test_dir_measured_bw_kb_cache(void)
+test_dir_measured_bw_kb_cache(void *arg)
 {
   /* Initial fake time_t for testing */
   time_t curr = MBWC_INIT_TIME;
@@ -637,6 +642,7 @@ test_dir_measured_bw_kb_cache(void)
   time_t as_of;
 
   /* First, clear the cache and assert that it's empty */
+  (void)arg;
   dirserv_clear_measured_bw_cache();
   tt_int_op(dirserv_get_measured_bw_cache_size(),==, 0);
   /*
@@ -700,7 +706,7 @@ test_dir_measured_bw_kb_cache(void)
 }
 
 static void
-test_dir_param_voting(void)
+test_dir_param_voting(void *arg)
 {
   networkstatus_t vote1, vote2, vote3, vote4;
   smartlist_t *votes = smartlist_new();
@@ -709,6 +715,7 @@ test_dir_param_voting(void)
   /* dirvote_compute_params only looks at the net_params field of the votes,
      so that's all we need to set.
    */
+  (void)arg;
   memset(&vote1, 0, sizeof(vote1));
   memset(&vote2, 0, sizeof(vote2));
   memset(&vote3, 0, sizeof(vote3));
@@ -1693,8 +1700,9 @@ test_a_networkstatus(
 /** Run unit tests for generating and parsing V3 consensus networkstatus
  * documents. */
 static void
-test_dir_v3_networkstatus(void)
+test_dir_v3_networkstatus(void *arg)
 {
+  (void)arg;
   test_a_networkstatus(gen_routerstatus_for_v3ns,
                        vote_tweaks_for_v3ns,
                        test_vrs_for_v3ns,
@@ -2238,9 +2246,10 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now)
  */
 
 static void
-test_dir_clip_unmeasured_bw_kb(void)
+test_dir_clip_unmeasured_bw_kb(void *arg)
 {
   /* Run the test with the default clip bandwidth */
+  (void)arg;
   alternate_clip_bw = 0;
   test_a_networkstatus(gen_routerstatus_for_umbw,
                        vote_tweaks_for_umbw,
@@ -2255,7 +2264,7 @@ test_dir_clip_unmeasured_bw_kb(void)
  */
 
 static void
-test_dir_clip_unmeasured_bw_kb_alt(void)
+test_dir_clip_unmeasured_bw_kb_alt(void *arg)
 {
   /*
    * Try a different one; this value is chosen so that the below-the-cutoff
@@ -2263,6 +2272,7 @@ test_dir_clip_unmeasured_bw_kb_alt(void)
    * DEFAULT_MAX_UNMEASURED_BW_KB and if the consensus incorrectly uses that
    * cutoff it will fail the test.
    */
+  (void)arg;
   alternate_clip_bw = 3 * DEFAULT_MAX_UNMEASURED_BW_KB;
   test_a_networkstatus(gen_routerstatus_for_umbw,
                        vote_tweaks_for_umbw,
@@ -2374,7 +2384,7 @@ test_dir_http_handling(void *args)
 }
 
 #define DIR_LEGACY(name)                                                   \
-  { #name, legacy_test_helper, TT_FORK, &legacy_setup, test_dir_ ## name }
+  { #name, test_dir_ ## name , TT_FORK, NULL, NULL }
 
 #define DIR(name,flags)                              \
   { #name, test_dir_##name, (flags), NULL, NULL }
diff --git a/src/test/test_introduce.c b/src/test/test_introduce.c
index b841a33d05..17ee01d9b8 100644
--- a/src/test/test_introduce.c
+++ b/src/test/test_introduce.c
@@ -394,8 +394,9 @@ make_intro_from_plaintext(
  */
 
 static void
-test_introduce_decrypt_v0(void)
+test_introduce_decrypt_v0(void *arg)
 {
+  (void)arg;
   do_decrypt_test(v0_test_plaintext, sizeof(v0_test_plaintext));
 }
 
@@ -403,8 +404,9 @@ test_introduce_decrypt_v0(void)
  */
 
 static void
-test_introduce_decrypt_v1(void)
+test_introduce_decrypt_v1(void *arg)
 {
+  (void)arg;
   do_decrypt_test(v1_test_plaintext, sizeof(v1_test_plaintext));
 }
 
@@ -412,8 +414,9 @@ test_introduce_decrypt_v1(void)
  */
 
 static void
-test_introduce_decrypt_v2(void)
+test_introduce_decrypt_v2(void *arg)
 {
+  (void)arg;
   do_decrypt_test(v2_test_plaintext, sizeof(v2_test_plaintext));
 }
 
@@ -421,8 +424,9 @@ test_introduce_decrypt_v2(void)
  */
 
 static void
-test_introduce_decrypt_v3(void)
+test_introduce_decrypt_v3(void *arg)
 {
+  (void)arg;
   do_decrypt_test(
       v3_no_auth_test_plaintext, sizeof(v3_no_auth_test_plaintext));
   do_decrypt_test(
@@ -433,8 +437,9 @@ test_introduce_decrypt_v3(void)
  */
 
 static void
-test_introduce_early_parse_v0(void)
+test_introduce_early_parse_v0(void *arg)
 {
+  (void)arg;
   do_early_parse_test(v0_test_plaintext, sizeof(v0_test_plaintext));
 }
 
@@ -442,8 +447,9 @@ test_introduce_early_parse_v0(void)
  */
 
 static void
-test_introduce_early_parse_v1(void)
+test_introduce_early_parse_v1(void *arg)
 {
+  (void)arg;
   do_early_parse_test(v1_test_plaintext, sizeof(v1_test_plaintext));
 }
 
@@ -451,8 +457,9 @@ test_introduce_early_parse_v1(void)
  */
 
 static void
-test_introduce_early_parse_v2(void)
+test_introduce_early_parse_v2(void *arg)
 {
+  (void)arg;
   do_early_parse_test(v2_test_plaintext, sizeof(v2_test_plaintext));
 }
 
@@ -460,8 +467,9 @@ test_introduce_early_parse_v2(void)
  */
 
 static void
-test_introduce_early_parse_v3(void)
+test_introduce_early_parse_v3(void *arg)
 {
+  (void)arg;
   do_early_parse_test(
       v3_no_auth_test_plaintext, sizeof(v3_no_auth_test_plaintext));
   do_early_parse_test(
@@ -472,8 +480,9 @@ test_introduce_early_parse_v3(void)
  */
 
 static void
-test_introduce_late_parse_v0(void)
+test_introduce_late_parse_v0(void *arg)
 {
+  (void)arg;
   do_late_parse_test(v0_test_plaintext, sizeof(v0_test_plaintext));
 }
 
@@ -481,8 +490,9 @@ test_introduce_late_parse_v0(void)
  */
 
 static void
-test_introduce_late_parse_v1(void)
+test_introduce_late_parse_v1(void *arg)
 {
+  (void)arg;
   do_late_parse_test(v1_test_plaintext, sizeof(v1_test_plaintext));
 }
 
@@ -490,8 +500,9 @@ test_introduce_late_parse_v1(void)
  */
 
 static void
-test_introduce_late_parse_v2(void)
+test_introduce_late_parse_v2(void *arg)
 {
+  (void)arg;
   do_late_parse_test(v2_test_plaintext, sizeof(v2_test_plaintext));
 }
 
@@ -499,8 +510,9 @@ test_introduce_late_parse_v2(void)
  */
 
 static void
-test_introduce_late_parse_v3(void)
+test_introduce_late_parse_v3(void *arg)
 {
+  (void)arg;
   do_late_parse_test(
       v3_no_auth_test_plaintext, sizeof(v3_no_auth_test_plaintext));
   do_late_parse_test(
@@ -508,7 +520,7 @@ test_introduce_late_parse_v3(void)
 }
 
 #define INTRODUCE_LEGACY(name) \
-  { #name, legacy_test_helper, 0, &legacy_setup, test_introduce_ ## name }
+  { #name, test_introduce_ ## name , 0, NULL, NULL }
 
 struct testcase_t introduce_tests[] = {
   INTRODUCE_LEGACY(early_parse_v0),
diff --git a/src/test/test_pt.c b/src/test/test_pt.c
index aa616abf3e..61ade84e3a 100644
--- a/src/test/test_pt.c
+++ b/src/test/test_pt.c
@@ -27,13 +27,14 @@ reset_mp(managed_proxy_t *mp)
 }
 
 static void
-test_pt_parsing(void)
+test_pt_parsing(void *arg)
 {
   char line[200];
   transport_t *transport = NULL;
   tor_addr_t test_addr;
 
   managed_proxy_t *mp = tor_malloc_zero(sizeof(managed_proxy_t));
+  (void)arg;
   mp->conf_state = PT_PROTO_INFANT;
   mp->transports = smartlist_new();
 
@@ -187,11 +188,12 @@ test_pt_get_transport_options(void *arg)
 }
 
 static void
-test_pt_protocol(void)
+test_pt_protocol(void *arg)
 {
   char line[200];
 
   managed_proxy_t *mp = tor_malloc_zero(sizeof(managed_proxy_t));
+  (void)arg;
   mp->conf_state = PT_PROTO_LAUNCHED;
   mp->transports = smartlist_new();
   mp->argv = tor_calloc(sizeof(char *), 2);
@@ -529,7 +531,7 @@ test_get_pt_proxy_uri(void *arg)
 }
 
 #define PT_LEGACY(name)                                               \
-  { #name, legacy_test_helper, 0, &legacy_setup, test_pt_ ## name }
+  { #name, test_pt_ ## name , 0, NULL, NULL }
 
 struct testcase_t pt_tests[] = {
   PT_LEGACY(parsing),
diff --git a/src/test/test_replay.c b/src/test/test_replay.c
index d5e039ec26..2f543512b0 100644
--- a/src/test/test_replay.c
+++ b/src/test/test_replay.c
@@ -18,10 +18,11 @@ static const char *test_buffer =
   " mollit anim id est laborum.";
 
 static void
-test_replaycache_alloc(void)
+test_replaycache_alloc(void *arg)
 {
   replaycache_t *r = NULL;
 
+  (void)arg;
   r = replaycache_new(600, 300);
   tt_assert(r != NULL);
 
@@ -32,11 +33,12 @@ test_replaycache_alloc(void)
 }
 
 static void
-test_replaycache_badalloc(void)
+test_replaycache_badalloc(void *arg)
 {
   replaycache_t *r = NULL;
 
   /* Negative horizon should fail */
+  (void)arg;
   r = replaycache_new(-600, 300);
   tt_assert(r == NULL);
   /* Negative interval should get adjusted to zero */
@@ -55,8 +57,9 @@ test_replaycache_badalloc(void)
 }
 
 static void
-test_replaycache_free_null(void)
+test_replaycache_free_null(void *arg)
 {
+  (void)arg;
   replaycache_free(NULL);
   /* Assert that we're here without horrible death */
   tt_assert(1);
@@ -66,11 +69,12 @@ test_replaycache_free_null(void)
 }
 
 static void
-test_replaycache_miss(void)
+test_replaycache_miss(void *arg)
 {
   replaycache_t *r = NULL;
   int result;
 
+  (void)arg;
   r = replaycache_new(600, 300);
   tt_assert(r != NULL);
 
@@ -92,11 +96,12 @@ test_replaycache_miss(void)
 }
 
 static void
-test_replaycache_hit(void)
+test_replaycache_hit(void *arg)
 {
   replaycache_t *r = NULL;
   int result;
 
+  (void)arg;
   r = replaycache_new(600, 300);
   tt_assert(r != NULL);
 
@@ -117,11 +122,12 @@ test_replaycache_hit(void)
 }
 
 static void
-test_replaycache_age(void)
+test_replaycache_age(void *arg)
 {
   replaycache_t *r = NULL;
   int result;
 
+  (void)arg;
   r = replaycache_new(600, 300);
   tt_assert(r != NULL);
 
@@ -147,12 +153,13 @@ test_replaycache_age(void)
 }
 
 static void
-test_replaycache_elapsed(void)
+test_replaycache_elapsed(void *arg)
 {
   replaycache_t *r = NULL;
   int result;
   time_t elapsed;
 
+  (void)arg;
   r = replaycache_new(600, 300);
   tt_assert(r != NULL);
 
@@ -174,11 +181,12 @@ test_replaycache_elapsed(void)
 }
 
 static void
-test_replaycache_noexpire(void)
+test_replaycache_noexpire(void *arg)
 {
   replaycache_t *r = NULL;
   int result;
 
+  (void)arg;
   r = replaycache_new(0, 0);
   tt_assert(r != NULL);
 
@@ -204,11 +212,12 @@ test_replaycache_noexpire(void)
 }
 
 static void
-test_replaycache_scrub(void)
+test_replaycache_scrub(void *arg)
 {
   replaycache_t *r = NULL;
   int result;
 
+  (void)arg;
   r = replaycache_new(600, 300);
   tt_assert(r != NULL);
 
@@ -245,12 +254,13 @@ test_replaycache_scrub(void)
 }
 
 static void
-test_replaycache_future(void)
+test_replaycache_future(void *arg)
 {
   replaycache_t *r = NULL;
   int result;
   time_t elapsed = 0;
 
+  (void)arg;
   r = replaycache_new(600, 300);
   tt_assert(r != NULL);
 
@@ -288,7 +298,7 @@ test_replaycache_future(void)
 }
 
 static void
-test_replaycache_realtime(void)
+test_replaycache_realtime(void *arg)
 {
   replaycache_t *r = NULL;
   /*
@@ -299,6 +309,7 @@ test_replaycache_realtime(void)
   int result;
 
   /* Test the realtime as well as *_internal() entry points */
+  (void)arg;
   r = replaycache_new(600, 300);
   tt_assert(r != NULL);
 
@@ -329,7 +340,7 @@ test_replaycache_realtime(void)
 }
 
 #define REPLAYCACHE_LEGACY(name) \
-  { #name, legacy_test_helper, 0, &legacy_setup, test_replaycache_ ## name }
+  { #name, test_replaycache_ ## name , 0, NULL, NULL }
 
 struct testcase_t replaycache_tests[] = {
   REPLAYCACHE_LEGACY(alloc),
diff --git a/src/test/test_util.c b/src/test/test_util.c
index 4c90153534..4e731cef2b 100644
--- a/src/test/test_util.c
+++ b/src/test/test_util.c
@@ -229,7 +229,7 @@ test_util_write_chunks_to_file(void *arg)
 }
 
 static void
-test_util_time(void)
+test_util_time(void *arg)
 {
   struct timeval start, end;
   struct tm a_time;
@@ -240,6 +240,7 @@ test_util_time(void)
 
   /* Test tv_udiff */
 
+  (void)arg;
   start.tv_sec = 5;
   start.tv_usec = 5000;
 
@@ -459,13 +460,14 @@ test_util_parse_http_time(void *arg)
 }
 
 static void
-test_util_config_line(void)
+test_util_config_line(void *arg)
 {
   char buf[1024];
   char *k=NULL, *v=NULL;
   const char *str;
 
   /* Test parse_config_line_from_str */
+  (void)arg;
   strlcpy(buf, "k v\n" " key    value with spaces   \n" "keykey val\n"
           "k2\n"
           "k3 \n" "\n" "   \n" "#comment\n"
@@ -596,7 +598,7 @@ test_util_config_line(void)
 }
 
 static void
-test_util_config_line_quotes(void)
+test_util_config_line_quotes(void *arg)
 {
   char buf1[1024];
   char buf2[128];
@@ -606,6 +608,7 @@ test_util_config_line_quotes(void)
   const char *str;
 
   /* Test parse_config_line_from_str */
+  (void)arg;
   strlcpy(buf1, "kTrailingSpace \"quoted value\"   \n"
           "kTrailingGarbage \"quoted value\"trailing garbage\n"
           , sizeof(buf1));
@@ -650,13 +653,14 @@ test_util_config_line_quotes(void)
 }
 
 static void
-test_util_config_line_comment_character(void)
+test_util_config_line_comment_character(void *arg)
 {
   char buf[1024];
   char *k=NULL, *v=NULL;
   const char *str;
 
   /* Test parse_config_line_from_str */
+  (void)arg;
   strlcpy(buf, "k1 \"# in quotes\"\n"
           "k2 some value    # some comment\n"
           "k3 /home/user/myTorNetwork#2\n"    /* Testcase for #1323 */
@@ -690,7 +694,7 @@ test_util_config_line_comment_character(void)
 }
 
 static void
-test_util_config_line_escaped_content(void)
+test_util_config_line_escaped_content(void *arg)
 {
   char buf1[1024];
   char buf2[128];
@@ -702,6 +706,7 @@ test_util_config_line_escaped_content(void)
   const char *str;
 
   /* Test parse_config_line_from_str */
+  (void)arg;
   strlcpy(buf1, "HexadecimalLower \"\\x2a\"\n"
           "HexadecimalUpper \"\\x2A\"\n"
           "HexadecimalUpperX \"\\X2A\"\n"
@@ -827,10 +832,11 @@ test_util_config_line_escaped_content(void)
 
 #ifndef _WIN32
 static void
-test_util_expand_filename(void)
+test_util_expand_filename(void *arg)
 {
   char *str;
 
+  (void)arg;
   setenv("HOME", "/home/itv", 1); /* For "internal test value" */
 
   str = expand_filename("");
@@ -925,11 +931,12 @@ test_util_expand_filename(void)
 
 /** Test tor_escape_str_for_pt_args(). */
 static void
-test_util_escape_string_socks(void)
+test_util_escape_string_socks(void *arg)
 {
   char *escaped_string = NULL;
 
   /** Simple backslash escape. */
+  (void)arg;
   escaped_string = tor_escape_str_for_pt_args("This is a backslash: \\",";\\");
   tt_assert(escaped_string);
   tt_str_op(escaped_string,==, "This is a backslash: \\\\");
@@ -983,13 +990,14 @@ test_util_string_is_key_value(void *ptr)
 
 /** Test basic string functionality. */
 static void
-test_util_strmisc(void)
+test_util_strmisc(void *arg)
 {
   char buf[1024];
   int i;
   char *cp, *cp_tmp = NULL;
 
   /* Test strl operations */
+  (void)arg;
   tt_int_op(5,==, strlcpy(buf, "Hello", 0));
   tt_int_op(5,==, strlcpy(buf, "Hello", 10));
   tt_str_op(buf,==, "Hello");
@@ -1297,9 +1305,10 @@ test_util_strmisc(void)
 }
 
 static void
-test_util_pow2(void)
+test_util_pow2(void *arg)
 {
   /* Test tor_log2(). */
+  (void)arg;
   tt_int_op(tor_log2(64),==, 6);
   tt_int_op(tor_log2(65),==, 6);
   tt_int_op(tor_log2(63),==, 5);
@@ -1395,13 +1404,14 @@ thread_test_func_(void* _s)
 
 /** Run unit tests for threading logic. */
 static void
-test_util_threads(void)
+test_util_threads(void *arg)
 {
   char *s1 = NULL, *s2 = NULL;
   int done = 0, timedout = 0;
   time_t started;
 #ifndef _WIN32
   struct timeval tv;
+  (void)arg;
   tv.tv_sec=0;
   tv.tv_usec=100*1000;
 #endif
@@ -1470,13 +1480,14 @@ test_util_threads(void)
 
 /** Run unit tests for compression functions */
 static void
-test_util_gzip(void)
+test_util_gzip(void *arg)
 {
   char *buf1=NULL, *buf2=NULL, *buf3=NULL, *cp1, *cp2;
   const char *ccp2;
   size_t len1, len2;
   tor_zlib_state_t *state = NULL;
 
+  (void)arg;
   buf1 = tor_strdup("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAAAAAAAAAAAAAAAAZ");
   tt_assert(detect_compression_method(buf1, strlen(buf1)) == UNKNOWN_METHOD);
   if (is_gzip_supported()) {
@@ -1579,7 +1590,7 @@ test_util_gzip(void)
 
 /** Run unit tests for mmap() wrapper functionality. */
 static void
-test_util_mmap(void)
+test_util_mmap(void *arg)
 {
   char *fname1 = tor_strdup(get_fname("mapped_1"));
   char *fname2 = tor_strdup(get_fname("mapped_2"));
@@ -1588,6 +1599,7 @@ test_util_mmap(void)
   char *buf = tor_malloc(17000);
   tor_mmap_t *mapping = NULL;
 
+  (void)arg;
   crypto_rand(buf, buflen);
 
   mapping = tor_mmap_file(fname1);
@@ -1655,13 +1667,14 @@ test_util_mmap(void)
 
 /** Run unit tests for escaping/unescaping data for use by controllers. */
 static void
-test_util_control_formats(void)
+test_util_control_formats(void *arg)
 {
   char *out = NULL;
   const char *inp =
     "..This is a test\r\n.of the emergency \n..system.\r\n\rZ.\r\n";
   size_t sz;
 
+  (void)arg;
   sz = read_escaped_data(inp, strlen(inp), &out);
   tt_str_op(out,==,
              ".This is a test\nof the emergency \n.system.\n\rZ.\n");
@@ -1685,7 +1698,7 @@ test_util_control_formats(void)
   } while (0)
 
 static void
-test_util_sscanf(void)
+test_util_sscanf(void *arg)
 {
   unsigned u1, u2, u3;
   unsigned long ulng;
@@ -1696,6 +1709,7 @@ test_util_sscanf(void)
   double d1,d2,d3,d4;
 
   /* Simple tests (malformed patterns, literal matching, ...) */
+  (void)arg;
   tt_int_op(-1,==, tor_sscanf("123", "%i", &r)); /* %i is not supported */
   tt_int_op(-1,==, tor_sscanf("wrong", "%5c", s1)); /* %c cannot have a number. */
   tt_int_op(-1,==, tor_sscanf("hello", "%s", s1)); /* %s needs a number. */
@@ -2026,9 +2040,10 @@ test_util_sscanf(void)
 }
 
 static void
-test_util_path_is_relative(void)
+test_util_path_is_relative(void *arg)
 {
   /* OS-independent tests */
+  (void)arg;
   tt_int_op(1,==, path_is_relative(""));
   tt_int_op(1,==, path_is_relative("dir"));
   tt_int_op(1,==, path_is_relative("dir/"));
@@ -2063,12 +2078,13 @@ test_util_path_is_relative(void)
 
 /** Run unittests for memory pool allocator */
 static void
-test_util_mempool(void)
+test_util_mempool(void *arg)
 {
   mp_pool_t *pool = NULL;
   smartlist_t *allocated = NULL;
   int i;
 
+  (void)arg;
   pool = mp_pool_new(1, 100);
   tt_assert(pool);
   tt_assert(pool->new_chunk_capacity >= 100);
@@ -2123,13 +2139,14 @@ test_util_mempool(void)
 
 /** Run unittests for memory area allocator */
 static void
-test_util_memarea(void)
+test_util_memarea(void *arg)
 {
   memarea_t *area = memarea_new();
   char *p1, *p2, *p3, *p1_orig;
   void *malloced_ptr = NULL;
   int i;
 
+  (void)arg;
   tt_assert(area);
 
   p1_orig = p1 = memarea_alloc(area,64);
@@ -2220,12 +2237,13 @@ test_util_memarea(void)
 /** Run unit tests for utility functions to get file names relative to
  * the data directory. */
 static void
-test_util_datadir(void)
+test_util_datadir(void *arg)
 {
   char buf[1024];
   char *f = NULL;
   char *temp_dir = NULL;
 
+  (void)arg;
   temp_dir = get_datadir_fname(NULL);
   f = get_datadir_fname("state");
   tor_snprintf(buf, sizeof(buf), "%s"PATH_SEPARATOR"state", temp_dir);
@@ -2252,13 +2270,14 @@ test_util_datadir(void)
 }
 
 static void
-test_util_strtok(void)
+test_util_strtok(void *arg)
 {
   char buf[128];
   char buf2[128];
   int i;
   char *cp1, *cp2;
 
+  (void)arg;
   for (i = 0; i < 3; i++) {
     const char *pad1="", *pad2="";
     switch (i) {
@@ -3314,7 +3333,7 @@ test_util_split_lines(void *ptr)
 }
 
 static void
-test_util_di_ops(void)
+test_util_di_ops(void *arg)
 {
 #define LT -1
 #define GT 1
@@ -3334,6 +3353,7 @@ test_util_di_ops(void)
 
   int i;
 
+  (void)arg;
   for (i = 0; examples[i].a; ++i) {
     size_t len = strlen(examples[i].a);
     int eq1, eq2, neq1, neq2, cmp1, cmp2;
@@ -3859,7 +3879,7 @@ test_util_strclear(void *arg)
 }
 
 #define UTIL_LEGACY(name)                                               \
-  { #name, legacy_test_helper, 0, &legacy_setup, test_util_ ## name }
+  { #name, test_util_ ## name , 0, NULL, NULL }
 
 #define UTIL_TEST(name, flags)                          \
   { #name, test_util_ ## name, flags, NULL, NULL }