diff --git a/src/test/test.c b/src/test/test.c
index e836160bf4..516fa42b41 100644
--- a/src/test/test.c
+++ b/src/test/test.c
@@ -250,7 +250,7 @@ test_onion_handshake(void)
 
   /* client handshake 1. */
   memset(c_buf, 0, TAP_ONIONSKIN_CHALLENGE_LEN);
-  test_assert(! onion_skin_TAP_create(pk, &c_dh, c_buf));
+  tt_assert(! onion_skin_TAP_create(pk, &c_dh, c_buf));
 
   for (i = 1; i <= 3; ++i) {
     crypto_pk_t *k1, *k2;
@@ -267,16 +267,16 @@ test_onion_handshake(void)
 
     memset(s_buf, 0, TAP_ONIONSKIN_REPLY_LEN);
     memset(s_keys, 0, 40);
-    test_assert(! onion_skin_TAP_server_handshake(c_buf, k1, k2,
+    tt_assert(! onion_skin_TAP_server_handshake(c_buf, k1, k2,
                                                   s_buf, s_keys, 40));
 
     /* client handshake 2 */
     memset(c_keys, 0, 40);
-    test_assert(! onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40));
+    tt_assert(! onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40));
 
-    test_memeq(c_keys, s_keys, 40);
+    tt_mem_op(c_keys,==, s_keys, 40);
     memset(s_buf, 0, 40);
-    test_memneq(c_keys, s_buf, 40);
+    tt_mem_op(c_keys,!=, s_buf, 40);
   }
  done:
   crypto_dh_free(c_dh);
@@ -323,7 +323,7 @@ test_bad_onion_handshake(void *arg)
 
   /* client handshake 1: do it straight. */
   memset(c_buf, 0, TAP_ONIONSKIN_CHALLENGE_LEN);
-  test_assert(! onion_skin_TAP_create(pk, &c_dh, c_buf));
+  tt_assert(! onion_skin_TAP_create(pk, &c_dh, c_buf));
 
   /* Server: Case 3: we just don't have the right key. */
   tt_int_op(-1, ==,
@@ -351,7 +351,7 @@ test_bad_onion_handshake(void *arg)
   /* Let the client finish; make sure it can. */
   tt_int_op(0, ==,
             onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40));
-  test_memeq(s_keys, c_keys, 40);
+  tt_mem_op(s_keys,==, c_keys, 40);
 
   /* Client: Case 2: The server sent back a degenerate DH. */
   memset(s_buf, 0, sizeof(s_buf));
@@ -408,9 +408,9 @@ test_ntor_handshake(void *arg)
   tt_int_op(0, ==, onion_skin_ntor_client_handshake(c_state, s_buf,
                                                     c_keys, 400));
 
-  test_memeq(c_keys, s_keys, 400);
+  tt_mem_op(c_keys,==, s_keys, 400);
   memset(s_buf, 0, 40);
-  test_memneq(c_keys, s_buf, 40);
+  tt_mem_op(c_keys,!=, s_buf, 40);
 
  done:
   ntor_handshake_state_free(c_state);
@@ -438,24 +438,24 @@ test_onion_queues(void)
   create_cell_init(create2, CELL_CREATE, ONION_HANDSHAKE_TYPE_NTOR,
                    NTOR_ONIONSKIN_LEN, buf2);
 
-  test_eq(0, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
-  test_eq(0, onion_pending_add(circ1, create1));
+  tt_int_op(0,==, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
+  tt_int_op(0,==, onion_pending_add(circ1, create1));
   create1 = NULL;
-  test_eq(1, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
+  tt_int_op(1,==, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
 
-  test_eq(0, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
-  test_eq(0, onion_pending_add(circ2, create2));
+  tt_int_op(0,==, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
+  tt_int_op(0,==, onion_pending_add(circ2, create2));
   create2 = NULL;
-  test_eq(1, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
+  tt_int_op(1,==, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
 
-  test_eq_ptr(circ2, onion_next_task(&onionskin));
-  test_eq(1, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
-  test_eq(0, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
+  tt_ptr_op(circ2,==, onion_next_task(&onionskin));
+  tt_int_op(1,==, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
+  tt_int_op(0,==, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
   tt_ptr_op(onionskin, ==, create2_ptr);
 
   clear_pending_onions();
-  test_eq(0, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
-  test_eq(0, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
+  tt_int_op(0,==, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
+  tt_int_op(0,==, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
 
  done:
   circuit_free(TO_CIRCUIT(circ1));
@@ -518,11 +518,11 @@ test_circuit_timeout(void)
   } while (fabs(circuit_build_times_cdf(&initial, timeout0) -
                 circuit_build_times_cdf(&initial, timeout1)) > 0.02);
 
-  test_assert(estimate.total_build_times <= CBT_NCIRCUITS_TO_OBSERVE);
+  tt_assert(estimate.total_build_times <= CBT_NCIRCUITS_TO_OBSERVE);
 
   circuit_build_times_update_state(&estimate, state);
   circuit_build_times_free_timeouts(&final);
-  test_assert(circuit_build_times_parse_state(&final, state) == 0);
+  tt_assert(circuit_build_times_parse_state(&final, state) == 0);
 
   circuit_build_times_update_alpha(&final);
   timeout2 = circuit_build_times_calculate_timeout(&final,
@@ -532,7 +532,7 @@ test_circuit_timeout(void)
   log_notice(LD_CIRC, "Timeout2 is %f, Xm is %d", timeout2, final.Xm);
 
   /* 5% here because some accuracy is lost due to histogram conversion */
-  test_assert(fabs(circuit_build_times_cdf(&initial, timeout0) -
+  tt_assert(fabs(circuit_build_times_cdf(&initial, timeout0) -
                    circuit_build_times_cdf(&initial, timeout2)) < 0.05);
 
   for (runs = 0; runs < 50; runs++) {
@@ -555,8 +555,8 @@ test_circuit_timeout(void)
                 CBT_DEFAULT_QUANTILE_CUTOFF/100.0));
     }
 
-    test_assert(!circuit_build_times_network_check_changed(&estimate));
-    test_assert(!circuit_build_times_network_check_changed(&final));
+    tt_assert(!circuit_build_times_network_check_changed(&estimate));
+    tt_assert(!circuit_build_times_network_check_changed(&final));
 
     /* Reset liveness to be non-live */
     final.liveness.network_last_live = 0;
@@ -565,27 +565,27 @@ test_circuit_timeout(void)
     build_times_idx = estimate.build_times_idx;
     total_build_times = estimate.total_build_times;
 
-    test_assert(circuit_build_times_network_check_live(&estimate));
-    test_assert(circuit_build_times_network_check_live(&final));
+    tt_assert(circuit_build_times_network_check_live(&estimate));
+    tt_assert(circuit_build_times_network_check_live(&final));
 
     circuit_build_times_count_close(&estimate, 0,
             (time_t)(approx_time()-estimate.close_ms/1000.0-1));
     circuit_build_times_count_close(&final, 0,
             (time_t)(approx_time()-final.close_ms/1000.0-1));
 
-    test_assert(!circuit_build_times_network_check_live(&estimate));
-    test_assert(!circuit_build_times_network_check_live(&final));
+    tt_assert(!circuit_build_times_network_check_live(&estimate));
+    tt_assert(!circuit_build_times_network_check_live(&final));
 
     log_info(LD_CIRC, "idx: %d %d, tot: %d %d",
              build_times_idx, estimate.build_times_idx,
              total_build_times, estimate.total_build_times);
 
     /* Check rollback index. Should match top of loop. */
-    test_assert(build_times_idx == estimate.build_times_idx);
+    tt_assert(build_times_idx == estimate.build_times_idx);
     // This can fail if estimate.total_build_times == 1000, because
     // in that case, rewind actually causes us to lose timeouts
     if (total_build_times != CBT_NCIRCUITS_TO_OBSERVE)
-      test_assert(total_build_times == estimate.total_build_times);
+      tt_assert(total_build_times == estimate.total_build_times);
 
     /* Now simulate that the network has become live and we need
      * a change */
@@ -600,12 +600,12 @@ test_circuit_timeout(void)
       }
     }
 
-    test_assert(estimate.liveness.after_firsthop_idx == 0);
-    test_assert(final.liveness.after_firsthop_idx ==
+    tt_assert(estimate.liveness.after_firsthop_idx == 0);
+    tt_assert(final.liveness.after_firsthop_idx ==
                 CBT_DEFAULT_MAX_RECENT_TIMEOUT_COUNT-1);
 
-    test_assert(circuit_build_times_network_check_live(&estimate));
-    test_assert(circuit_build_times_network_check_live(&final));
+    tt_assert(circuit_build_times_network_check_live(&estimate));
+    tt_assert(circuit_build_times_network_check_live(&final));
 
     circuit_build_times_count_timeout(&final, 1);
   }
@@ -642,16 +642,16 @@ test_rend_fns(void)
   char address6[] = "foo.bar.abcdefghijklmnop.onion";
   char address7[] = ".abcdefghijklmnop.onion";
 
-  test_assert(BAD_HOSTNAME == parse_extended_hostname(address1));
-  test_assert(ONION_HOSTNAME == parse_extended_hostname(address2));
-  test_streq(address2, "aaaaaaaaaaaaaaaa");
-  test_assert(EXIT_HOSTNAME == parse_extended_hostname(address3));
-  test_assert(NORMAL_HOSTNAME == parse_extended_hostname(address4));
-  test_assert(ONION_HOSTNAME == parse_extended_hostname(address5));
-  test_streq(address5, "abcdefghijklmnop");
-  test_assert(ONION_HOSTNAME == parse_extended_hostname(address6));
-  test_streq(address6, "abcdefghijklmnop");
-  test_assert(BAD_HOSTNAME == parse_extended_hostname(address7));
+  tt_assert(BAD_HOSTNAME == parse_extended_hostname(address1));
+  tt_assert(ONION_HOSTNAME == parse_extended_hostname(address2));
+  tt_str_op(address2,==, "aaaaaaaaaaaaaaaa");
+  tt_assert(EXIT_HOSTNAME == parse_extended_hostname(address3));
+  tt_assert(NORMAL_HOSTNAME == parse_extended_hostname(address4));
+  tt_assert(ONION_HOSTNAME == parse_extended_hostname(address5));
+  tt_str_op(address5,==, "abcdefghijklmnop");
+  tt_assert(ONION_HOSTNAME == parse_extended_hostname(address6));
+  tt_str_op(address6,==, "abcdefghijklmnop");
+  tt_assert(BAD_HOSTNAME == parse_extended_hostname(address7));
 
   pk1 = pk_generate(0);
   pk2 = pk_generate(1);
@@ -684,40 +684,40 @@ test_rend_fns(void)
     intro->intro_key = crypto_pk_dup_key(pk2);
     smartlist_add(generated->intro_nodes, intro);
   }
-  test_assert(rend_encode_v2_descriptors(descs, generated, now, 0,
+  tt_assert(rend_encode_v2_descriptors(descs, generated, now, 0,
                                          REND_NO_AUTH, NULL, NULL) > 0);
-  test_assert(rend_compute_v2_desc_id(computed_desc_id, service_id_base32,
+  tt_assert(rend_compute_v2_desc_id(computed_desc_id, service_id_base32,
                                       NULL, now, 0) == 0);
-  test_memeq(((rend_encoded_v2_service_descriptor_t *)
-             smartlist_get(descs, 0))->desc_id, computed_desc_id, DIGEST_LEN);
-  test_assert(rend_parse_v2_service_descriptor(&parsed, parsed_desc_id,
+  tt_mem_op(((rend_encoded_v2_service_descriptor_t *)
+             smartlist_get(descs, 0))->desc_id,==, computed_desc_id, DIGEST_LEN);
+  tt_assert(rend_parse_v2_service_descriptor(&parsed, parsed_desc_id,
                                                &intro_points_encrypted,
                                                &intro_points_size,
                                                &encoded_size,
                                                &next_desc,
                                      ((rend_encoded_v2_service_descriptor_t *)
                                      smartlist_get(descs, 0))->desc_str) == 0);
-  test_assert(parsed);
-  test_memeq(((rend_encoded_v2_service_descriptor_t *)
-             smartlist_get(descs, 0))->desc_id, parsed_desc_id, DIGEST_LEN);
-  test_eq(rend_parse_introduction_points(parsed, intro_points_encrypted,
-                                         intro_points_size), 3);
-  test_assert(!crypto_pk_cmp_keys(generated->pk, parsed->pk));
-  test_eq(parsed->timestamp, now);
-  test_eq(parsed->version, 2);
-  test_eq(parsed->protocols, 42);
-  test_eq(smartlist_len(parsed->intro_nodes), 3);
+  tt_assert(parsed);
+  tt_mem_op(((rend_encoded_v2_service_descriptor_t *)
+             smartlist_get(descs, 0))->desc_id,==, parsed_desc_id, DIGEST_LEN);
+  tt_int_op(rend_parse_introduction_points(parsed, intro_points_encrypted,
+                                         intro_points_size),==, 3);
+  tt_assert(!crypto_pk_cmp_keys(generated->pk, parsed->pk));
+  tt_int_op(parsed->timestamp,==, now);
+  tt_int_op(parsed->version,==, 2);
+  tt_int_op(parsed->protocols,==, 42);
+  tt_int_op(smartlist_len(parsed->intro_nodes),==, 3);
   for (i = 0; i < smartlist_len(parsed->intro_nodes); i++) {
     rend_intro_point_t *par_intro = smartlist_get(parsed->intro_nodes, i),
       *gen_intro = smartlist_get(generated->intro_nodes, i);
     extend_info_t *par_info = par_intro->extend_info;
     extend_info_t *gen_info = gen_intro->extend_info;
-    test_assert(!crypto_pk_cmp_keys(gen_info->onion_key, par_info->onion_key));
-    test_memeq(gen_info->identity_digest, par_info->identity_digest,
+    tt_assert(!crypto_pk_cmp_keys(gen_info->onion_key, par_info->onion_key));
+    tt_mem_op(gen_info->identity_digest,==, par_info->identity_digest,
                DIGEST_LEN);
-    test_streq(gen_info->nickname, par_info->nickname);
-    test_assert(tor_addr_eq(&gen_info->addr, &par_info->addr));
-    test_eq(gen_info->port, par_info->port);
+    tt_str_op(gen_info->nickname,==, par_info->nickname);
+    tt_assert(tor_addr_eq(&gen_info->addr, &par_info->addr));
+    tt_int_op(gen_info->port,==, par_info->port);
   }
 
   rend_service_descriptor_free(parsed);
@@ -825,23 +825,23 @@ 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. */
-  test_eq(0, geoip_parse_entry("10,50,AB", AF_INET));
-  test_eq(0, geoip_parse_entry("52,90,XY", AF_INET));
-  test_eq(0, geoip_parse_entry("95,100,AB", AF_INET));
-  test_eq(0, geoip_parse_entry("\"105\",\"140\",\"ZZ\"", AF_INET));
-  test_eq(0, geoip_parse_entry("\"150\",\"190\",\"XY\"", AF_INET));
-  test_eq(0, geoip_parse_entry("\"200\",\"250\",\"AB\"", AF_INET));
+  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));
+  tt_int_op(0,==, geoip_parse_entry("\"105\",\"140\",\"ZZ\"", AF_INET));
+  tt_int_op(0,==, geoip_parse_entry("\"150\",\"190\",\"XY\"", AF_INET));
+  tt_int_op(0,==, geoip_parse_entry("\"200\",\"250\",\"AB\"", AF_INET));
 
   /* Populate the IPv6 DB equivalently with fake IPs in the same range */
-  test_eq(0, geoip_parse_entry("::a,::32,AB", AF_INET6));
-  test_eq(0, geoip_parse_entry("::34,::5a,XY", AF_INET6));
-  test_eq(0, geoip_parse_entry("::5f,::64,AB", AF_INET6));
-  test_eq(0, geoip_parse_entry("::69,::8c,ZZ", AF_INET6));
-  test_eq(0, geoip_parse_entry("::96,::be,XY", AF_INET6));
-  test_eq(0, geoip_parse_entry("::c8,::fa,AB", AF_INET6));
+  tt_int_op(0,==, geoip_parse_entry("::a,::32,AB", AF_INET6));
+  tt_int_op(0,==, geoip_parse_entry("::34,::5a,XY", AF_INET6));
+  tt_int_op(0,==, geoip_parse_entry("::5f,::64,AB", AF_INET6));
+  tt_int_op(0,==, geoip_parse_entry("::69,::8c,ZZ", AF_INET6));
+  tt_int_op(0,==, geoip_parse_entry("::96,::be,XY", AF_INET6));
+  tt_int_op(0,==, geoip_parse_entry("::c8,::fa,AB", AF_INET6));
 
   /* We should have 4 countries: ??, ab, xy, zz. */
-  test_eq(4, geoip_get_n_countries());
+  tt_int_op(4,==, geoip_get_n_countries());
   memset(&in6, 0, sizeof(in6));
 
   CHECK_COUNTRY("??", 3);
@@ -852,9 +852,9 @@ test_geoip(void)
   CHECK_COUNTRY("xy", 190);
   CHECK_COUNTRY("??", 2000);
 
-  test_eq(0, geoip_get_country_by_ipv4(3));
+  tt_int_op(0,==, geoip_get_country_by_ipv4(3));
   SET_TEST_IPV6(3);
-  test_eq(0, geoip_get_country_by_ipv6(&in6));
+  tt_int_op(0,==, geoip_get_country_by_ipv6(&in6));
 
   get_options_mutable()->BridgeRelay = 1;
   get_options_mutable()->BridgeRecordUsageByCountry = 1;
@@ -877,41 +877,41 @@ test_geoip(void)
     geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
   }
   geoip_get_client_history(GEOIP_CLIENT_CONNECT, &s, &v);
-  test_assert(s);
-  test_assert(v);
-  test_streq("zz=24,ab=16,xy=8", s);
-  test_streq("v4=16,v6=16", v);
+  tt_assert(s);
+  tt_assert(v);
+  tt_str_op("zz=24,ab=16,xy=8",==, s);
+  tt_str_op("v4=16,v6=16",==, v);
   tor_free(s);
   tor_free(v);
 
   /* Now clear out all the AB observations. */
   geoip_remove_old_clients(now-6000);
   geoip_get_client_history(GEOIP_CLIENT_CONNECT, &s, &v);
-  test_assert(s);
-  test_assert(v);
-  test_streq("zz=24,xy=8", s);
-  test_streq("v4=16,v6=16", v);
+  tt_assert(s);
+  tt_assert(v);
+  tt_str_op("zz=24,xy=8",==, s);
+  tt_str_op("v4=16,v6=16",==, v);
   tor_free(s);
   tor_free(v);
 
   /* Start testing bridge statistics by making sure that we don't output
    * bridge stats without initializing them. */
   s = geoip_format_bridge_stats(now + 86400);
-  test_assert(!s);
+  tt_assert(!s);
 
   /* Initialize stats and generate the bridge-stats history string out of
    * the connecting clients added above. */
   geoip_bridge_stats_init(now);
   s = geoip_format_bridge_stats(now + 86400);
-  test_assert(s);
-  test_streq(bridge_stats_1, s);
+  tt_assert(s);
+  tt_str_op(bridge_stats_1,==, s);
   tor_free(s);
 
   /* Stop collecting bridge stats and make sure we don't write a history
    * string anymore. */
   geoip_bridge_stats_term();
   s = geoip_format_bridge_stats(now + 86400);
-  test_assert(!s);
+  tt_assert(!s);
 
   /* Stop being a bridge and start being a directory mirror that gathers
    * directory request statistics. */
@@ -925,7 +925,7 @@ test_geoip(void)
   SET_TEST_ADDRESS(100);
   geoip_note_client_seen(GEOIP_CLIENT_NETWORKSTATUS, &addr, NULL, now);
   s = geoip_format_dirreq_stats(now + 86400);
-  test_assert(!s);
+  tt_assert(!s);
 
   /* Initialize stats, note one connecting client, and generate the
    * dirreq-stats history string. */
@@ -933,7 +933,7 @@ test_geoip(void)
   SET_TEST_ADDRESS(100);
   geoip_note_client_seen(GEOIP_CLIENT_NETWORKSTATUS, &addr, NULL, now);
   s = geoip_format_dirreq_stats(now + 86400);
-  test_streq(dirreq_stats_1, s);
+  tt_str_op(dirreq_stats_1,==, s);
   tor_free(s);
 
   /* Stop collecting stats, add another connecting client, and ensure we
@@ -942,7 +942,7 @@ test_geoip(void)
   SET_TEST_ADDRESS(101);
   geoip_note_client_seen(GEOIP_CLIENT_NETWORKSTATUS, &addr, NULL, now);
   s = geoip_format_dirreq_stats(now + 86400);
-  test_assert(!s);
+  tt_assert(!s);
 
   /* Re-start stats, add a connecting client, reset stats, and make sure
    * that we get an all empty history string. */
@@ -951,20 +951,20 @@ test_geoip(void)
   geoip_note_client_seen(GEOIP_CLIENT_NETWORKSTATUS, &addr, NULL, now);
   geoip_reset_dirreq_stats(now);
   s = geoip_format_dirreq_stats(now + 86400);
-  test_streq(dirreq_stats_2, s);
+  tt_str_op(dirreq_stats_2,==, s);
   tor_free(s);
 
   /* Note a successful network status response and make sure that it
    * appears in the history string. */
   geoip_note_ns_response(GEOIP_SUCCESS);
   s = geoip_format_dirreq_stats(now + 86400);
-  test_streq(dirreq_stats_3, s);
+  tt_str_op(dirreq_stats_3,==, s);
   tor_free(s);
 
   /* Start a tunneled directory request. */
   geoip_start_dirreq((uint64_t) 1, 1024, DIRREQ_TUNNELED);
   s = geoip_format_dirreq_stats(now + 86400);
-  test_streq(dirreq_stats_4, s);
+  tt_str_op(dirreq_stats_4,==, s);
   tor_free(s);
 
   /* Stop collecting directory request statistics and start gathering
@@ -978,7 +978,7 @@ test_geoip(void)
   SET_TEST_ADDRESS(100);
   geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
   s = geoip_format_entry_stats(now + 86400);
-  test_assert(!s);
+  tt_assert(!s);
 
   /* Initialize stats, note one connecting client, and generate the
    * entry-stats history string. */
@@ -986,7 +986,7 @@ test_geoip(void)
   SET_TEST_ADDRESS(100);
   geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
   s = geoip_format_entry_stats(now + 86400);
-  test_streq(entry_stats_1, s);
+  tt_str_op(entry_stats_1,==, s);
   tor_free(s);
 
   /* Stop collecting stats, add another connecting client, and ensure we
@@ -995,7 +995,7 @@ test_geoip(void)
   SET_TEST_ADDRESS(101);
   geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
   s = geoip_format_entry_stats(now + 86400);
-  test_assert(!s);
+  tt_assert(!s);
 
   /* Re-start stats, add a connecting client, reset stats, and make sure
    * that we get an all empty history string. */
@@ -1004,7 +1004,7 @@ test_geoip(void)
   geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
   geoip_reset_entry_stats(now);
   s = geoip_format_entry_stats(now + 86400);
-  test_streq(entry_stats_2, s);
+  tt_str_op(entry_stats_2,==, s);
   tor_free(s);
 
   /* Stop collecting entry statistics. */
@@ -1076,7 +1076,7 @@ test_geoip_with_pt(void)
   /* Test the transport history string. */
   s = geoip_get_transport_history();
   tor_assert(s);
-  test_streq(s, "<OR>=8,alpha=16,beta=8,charlie=16,ddr=136,"
+  tt_str_op(s,==, "<OR>=8,alpha=16,beta=8,charlie=16,ddr=136,"
              "entropy=8,fire=8,google=8");
 
   /* Stop collecting entry statistics. */
@@ -1104,7 +1104,7 @@ test_stats(void)
   rep_hist_note_exit_stream_opened(80);
   rep_hist_note_exit_bytes(80, 100, 10000);
   s = rep_hist_format_exit_stats(now + 86400);
-  test_assert(!s);
+  tt_assert(!s);
 
   /* Initialize stats, note some streams and bytes, and generate history
    * string. */
@@ -1115,10 +1115,10 @@ test_stats(void)
   rep_hist_note_exit_bytes(443, 100, 10000);
   rep_hist_note_exit_bytes(443, 100, 10000);
   s = rep_hist_format_exit_stats(now + 86400);
-  test_streq("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n"
+  tt_str_op("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n"
              "exit-kibibytes-written 80=1,443=1,other=0\n"
              "exit-kibibytes-read 80=10,443=20,other=0\n"
-             "exit-streams-opened 80=4,443=4,other=0\n", s);
+             "exit-streams-opened 80=4,443=4,other=0\n",==, s);
   tor_free(s);
 
   /* Add a few bytes on 10 more ports and ensure that only the top 10
@@ -1128,13 +1128,13 @@ test_stats(void)
     rep_hist_note_exit_stream_opened(i);
   }
   s = rep_hist_format_exit_stats(now + 86400);
-  test_streq("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n"
+  tt_str_op("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n"
              "exit-kibibytes-written 52=1,53=1,54=1,55=1,56=1,57=1,58=1,"
              "59=1,80=1,443=1,other=1\n"
              "exit-kibibytes-read 52=1,53=1,54=1,55=1,56=1,57=1,58=1,"
              "59=1,80=10,443=20,other=1\n"
              "exit-streams-opened 52=4,53=4,54=4,55=4,56=4,57=4,58=4,"
-             "59=4,80=4,443=4,other=4\n", s);
+             "59=4,80=4,443=4,other=4\n",==, s);
   tor_free(s);
 
   /* Stop collecting stats, add some bytes, and ensure we don't generate
@@ -1142,7 +1142,7 @@ test_stats(void)
   rep_hist_exit_stats_term();
   rep_hist_note_exit_bytes(80, 100, 10000);
   s = rep_hist_format_exit_stats(now + 86400);
-  test_assert(!s);
+  tt_assert(!s);
 
   /* Re-start stats, add some bytes, reset stats, and see what history we
    * get when observing no streams or bytes at all. */
@@ -1151,17 +1151,17 @@ test_stats(void)
   rep_hist_note_exit_bytes(80, 100, 10000);
   rep_hist_reset_exit_stats(now);
   s = rep_hist_format_exit_stats(now + 86400);
-  test_streq("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n"
+  tt_str_op("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n"
              "exit-kibibytes-written other=0\n"
              "exit-kibibytes-read other=0\n"
-             "exit-streams-opened other=0\n", s);
+             "exit-streams-opened other=0\n",==, s);
   tor_free(s);
 
   /* Continue with testing connection statistics; we shouldn't collect
    * conn stats without initializing them. */
   rep_hist_note_or_conn_bytes(1, 20, 400, now);
   s = rep_hist_format_conn_stats(now + 86400);
-  test_assert(!s);
+  tt_assert(!s);
 
   /* Initialize stats, note bytes, and generate history string. */
   rep_hist_conn_stats_init(now);
@@ -1170,7 +1170,7 @@ test_stats(void)
   rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 10);
   rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 15);
   s = rep_hist_format_conn_stats(now + 86400);
-  test_streq("conn-bi-direct 2010-08-12 13:27:30 (86400 s) 0,0,1,0\n", s);
+  tt_str_op("conn-bi-direct 2010-08-12 13:27:30 (86400 s) 0,0,1,0\n",==, s);
   tor_free(s);
 
   /* Stop collecting stats, add some bytes, and ensure we don't generate
@@ -1178,7 +1178,7 @@ test_stats(void)
   rep_hist_conn_stats_term();
   rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 15);
   s = rep_hist_format_conn_stats(now + 86400);
-  test_assert(!s);
+  tt_assert(!s);
 
   /* Re-start stats, add some bytes, reset stats, and see what history we
    * get when observing no bytes at all. */
@@ -1189,26 +1189,26 @@ test_stats(void)
   rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 15);
   rep_hist_reset_conn_stats(now);
   s = rep_hist_format_conn_stats(now + 86400);
-  test_streq("conn-bi-direct 2010-08-12 13:27:30 (86400 s) 0,0,0,0\n", s);
+  tt_str_op("conn-bi-direct 2010-08-12 13:27:30 (86400 s) 0,0,0,0\n",==, s);
   tor_free(s);
 
   /* Continue with testing buffer statistics; we shouldn't collect buffer
    * stats without initializing them. */
   rep_hist_add_buffer_stats(2.0, 2.0, 20);
   s = rep_hist_format_buffer_stats(now + 86400);
-  test_assert(!s);
+  tt_assert(!s);
 
   /* Initialize stats, add statistics for a single circuit, and generate
    * the history string. */
   rep_hist_buffer_stats_init(now);
   rep_hist_add_buffer_stats(2.0, 2.0, 20);
   s = rep_hist_format_buffer_stats(now + 86400);
-  test_streq("cell-stats-end 2010-08-12 13:27:30 (86400 s)\n"
+  tt_str_op("cell-stats-end 2010-08-12 13:27:30 (86400 s)\n"
              "cell-processed-cells 20,0,0,0,0,0,0,0,0,0\n"
              "cell-queued-cells 2.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,"
                                "0.00,0.00\n"
              "cell-time-in-queue 2,0,0,0,0,0,0,0,0,0\n"
-             "cell-circuits-per-decile 1\n", s);
+             "cell-circuits-per-decile 1\n",==, s);
   tor_free(s);
 
   /* Add nineteen more circuit statistics to the one that's already in the
@@ -1218,12 +1218,12 @@ test_stats(void)
   for (i = 20; i < 30; i++)
     rep_hist_add_buffer_stats(3.5, 3.5, i);
   s = rep_hist_format_buffer_stats(now + 86400);
-  test_streq("cell-stats-end 2010-08-12 13:27:30 (86400 s)\n"
+  tt_str_op("cell-stats-end 2010-08-12 13:27:30 (86400 s)\n"
              "cell-processed-cells 29,28,27,26,25,24,23,22,21,20\n"
              "cell-queued-cells 2.75,2.75,2.75,2.75,2.75,2.75,2.75,2.75,"
                                "2.75,2.75\n"
              "cell-time-in-queue 3,3,3,3,3,3,3,3,3,3\n"
-             "cell-circuits-per-decile 2\n", s);
+             "cell-circuits-per-decile 2\n",==, s);
   tor_free(s);
 
   /* Stop collecting stats, add statistics for one circuit, and ensure we
@@ -1231,7 +1231,7 @@ test_stats(void)
   rep_hist_buffer_stats_term();
   rep_hist_add_buffer_stats(2.0, 2.0, 20);
   s = rep_hist_format_buffer_stats(now + 86400);
-  test_assert(!s);
+  tt_assert(!s);
 
   /* Re-start stats, add statistics for one circuit, reset stats, and make
    * sure that the history has all zeros. */
@@ -1239,12 +1239,12 @@ test_stats(void)
   rep_hist_add_buffer_stats(2.0, 2.0, 20);
   rep_hist_reset_buffer_stats(now);
   s = rep_hist_format_buffer_stats(now + 86400);
-  test_streq("cell-stats-end 2010-08-12 13:27:30 (86400 s)\n"
+  tt_str_op("cell-stats-end 2010-08-12 13:27:30 (86400 s)\n"
              "cell-processed-cells 0,0,0,0,0,0,0,0,0,0\n"
              "cell-queued-cells 0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,"
                                "0.00,0.00\n"
              "cell-time-in-queue 0,0,0,0,0,0,0,0,0,0\n"
-             "cell-circuits-per-decile 0\n", s);
+             "cell-circuits-per-decile 0\n",==, s);
 
  done:
   tor_free(s);
diff --git a/src/test/test_addr.c b/src/test/test_addr.c
index 50011e606b..083ae2d061 100644
--- a/src/test/test_addr.c
+++ b/src/test/test_addr.c
@@ -18,41 +18,41 @@ test_addr_basic(void)
 
   /* Test addr_port_lookup */
   cp = NULL; u32 = 3; u16 = 3;
-  test_assert(!addr_port_lookup(LOG_WARN, "1.2.3.4", &cp, &u32, &u16));
-  test_streq(cp, "1.2.3.4");
-  test_eq(u32, 0x01020304u);
-  test_eq(u16, 0);
+  tt_assert(!addr_port_lookup(LOG_WARN, "1.2.3.4", &cp, &u32, &u16));
+  tt_str_op(cp,==, "1.2.3.4");
+  tt_int_op(u32,==, 0x01020304u);
+  tt_int_op(u16,==, 0);
   tor_free(cp);
-  test_assert(!addr_port_lookup(LOG_WARN, "4.3.2.1:99", &cp, &u32, &u16));
-  test_streq(cp, "4.3.2.1");
-  test_eq(u32, 0x04030201u);
-  test_eq(u16, 99);
+  tt_assert(!addr_port_lookup(LOG_WARN, "4.3.2.1:99", &cp, &u32, &u16));
+  tt_str_op(cp,==, "4.3.2.1");
+  tt_int_op(u32,==, 0x04030201u);
+  tt_int_op(u16,==, 99);
   tor_free(cp);
-  test_assert(!addr_port_lookup(LOG_WARN, "nonexistent.address:4040",
+  tt_assert(!addr_port_lookup(LOG_WARN, "nonexistent.address:4040",
                                &cp, NULL, &u16));
-  test_streq(cp, "nonexistent.address");
-  test_eq(u16, 4040);
+  tt_str_op(cp,==, "nonexistent.address");
+  tt_int_op(u16,==, 4040);
   tor_free(cp);
-  test_assert(!addr_port_lookup(LOG_WARN, "localhost:9999", &cp, &u32, &u16));
-  test_streq(cp, "localhost");
-  test_eq(u32, 0x7f000001u);
-  test_eq(u16, 9999);
+  tt_assert(!addr_port_lookup(LOG_WARN, "localhost:9999", &cp, &u32, &u16));
+  tt_str_op(cp,==, "localhost");
+  tt_int_op(u32,==, 0x7f000001u);
+  tt_int_op(u16,==, 9999);
   tor_free(cp);
   u32 = 3;
-  test_assert(!addr_port_lookup(LOG_WARN, "localhost", NULL, &u32, &u16));
-  test_eq_ptr(cp, NULL);
-  test_eq(u32, 0x7f000001u);
-  test_eq(u16, 0);
+  tt_assert(!addr_port_lookup(LOG_WARN, "localhost", NULL, &u32, &u16));
+  tt_ptr_op(cp,==, NULL);
+  tt_int_op(u32,==, 0x7f000001u);
+  tt_int_op(u16,==, 0);
   tor_free(cp);
 
-  test_assert(addr_port_lookup(LOG_WARN, "localhost:3", &cp, &u32, NULL));
+  tt_assert(addr_port_lookup(LOG_WARN, "localhost:3", &cp, &u32, NULL));
   tor_free(cp);
 
-  test_eq(0, addr_mask_get_bits(0x0u));
-  test_eq(32, addr_mask_get_bits(0xFFFFFFFFu));
-  test_eq(16, addr_mask_get_bits(0xFFFF0000u));
-  test_eq(31, addr_mask_get_bits(0xFFFFFFFEu));
-  test_eq(1, addr_mask_get_bits(0x80000000u));
+  tt_int_op(0,==, addr_mask_get_bits(0x0u));
+  tt_int_op(32,==, addr_mask_get_bits(0xFFFFFFFFu));
+  tt_int_op(16,==, addr_mask_get_bits(0xFFFF0000u));
+  tt_int_op(31,==, addr_mask_get_bits(0xFFFFFFFEu));
+  tt_int_op(1,==, addr_mask_get_bits(0x80000000u));
 
   /* Test inet_ntop */
   {
@@ -61,15 +61,15 @@ test_addr_basic(void)
     struct in_addr in;
 
     /* good round trip */
-    test_eq(tor_inet_pton(AF_INET, ip, &in), 1);
-    test_eq_ptr(tor_inet_ntop(AF_INET, &in, tmpbuf, sizeof(tmpbuf)), &tmpbuf);
-    test_streq(tmpbuf, ip);
+    tt_int_op(tor_inet_pton(AF_INET, ip, &in),==, 1);
+    tt_ptr_op(tor_inet_ntop(AF_INET, &in, tmpbuf, sizeof(tmpbuf)),==, &tmpbuf);
+    tt_str_op(tmpbuf,==, ip);
 
     /* just enough buffer length */
-    test_streq(tor_inet_ntop(AF_INET, &in, tmpbuf, strlen(ip) + 1), ip);
+    tt_str_op(tor_inet_ntop(AF_INET, &in, tmpbuf, strlen(ip) + 1),==, ip);
 
     /* too short buffer */
-    test_eq_ptr(tor_inet_ntop(AF_INET, &in, tmpbuf, strlen(ip)), NULL);
+    tt_ptr_op(tor_inet_ntop(AF_INET, &in, tmpbuf, strlen(ip)),==, NULL);
   }
 
  done:
@@ -199,23 +199,23 @@ test_addr_ip6_helpers(void)
     const char *ip_ffff = "::ffff:192.168.1.2";
 
     /* good round trip */
-    test_eq(tor_inet_pton(AF_INET6, ip, &a1), 1);
-    test_eq_ptr(tor_inet_ntop(AF_INET6, &a1, buf, sizeof(buf)), &buf);
-    test_streq(buf, ip);
+    tt_int_op(tor_inet_pton(AF_INET6, ip, &a1),==, 1);
+    tt_ptr_op(tor_inet_ntop(AF_INET6, &a1, buf, sizeof(buf)),==, &buf);
+    tt_str_op(buf,==, ip);
 
     /* good round trip - ::ffff:0:0 style */
-    test_eq(tor_inet_pton(AF_INET6, ip_ffff, &a2), 1);
-    test_eq_ptr(tor_inet_ntop(AF_INET6, &a2, buf, sizeof(buf)), &buf);
-    test_streq(buf, ip_ffff);
+    tt_int_op(tor_inet_pton(AF_INET6, ip_ffff, &a2),==, 1);
+    tt_ptr_op(tor_inet_ntop(AF_INET6, &a2, buf, sizeof(buf)),==, &buf);
+    tt_str_op(buf,==, ip_ffff);
 
     /* just long enough buffer (remember \0) */
-    test_streq(tor_inet_ntop(AF_INET6, &a1, buf, strlen(ip)+1), ip);
-    test_streq(tor_inet_ntop(AF_INET6, &a2, buf, strlen(ip_ffff)+1),
+    tt_str_op(tor_inet_ntop(AF_INET6, &a1, buf, strlen(ip)+1),==, ip);
+    tt_str_op(tor_inet_ntop(AF_INET6, &a2, buf, strlen(ip_ffff)+1),==,
                ip_ffff);
 
     /* too short buffer (remember \0) */
-    test_eq_ptr(tor_inet_ntop(AF_INET6, &a1, buf, strlen(ip)), NULL);
-    test_eq_ptr(tor_inet_ntop(AF_INET6, &a2, buf, strlen(ip_ffff)), NULL);
+    tt_ptr_op(tor_inet_ntop(AF_INET6, &a1, buf, strlen(ip)),==, NULL);
+    tt_ptr_op(tor_inet_ntop(AF_INET6, &a2, buf, strlen(ip_ffff)),==, NULL);
   }
 
   /* ==== Converting to and from sockaddr_t. */
@@ -224,16 +224,16 @@ test_addr_ip6_helpers(void)
   sin->sin_port = htons(9090);
   sin->sin_addr.s_addr = htonl(0x7f7f0102); /*127.127.1.2*/
   tor_addr_from_sockaddr(&t1, (struct sockaddr *)sin, &port1);
-  test_eq(tor_addr_family(&t1), AF_INET);
-  test_eq(tor_addr_to_ipv4h(&t1), 0x7f7f0102);
+  tt_int_op(tor_addr_family(&t1),==, AF_INET);
+  tt_int_op(tor_addr_to_ipv4h(&t1),==, 0x7f7f0102);
   tt_int_op(port1, ==, 9090);
 
   memset(&sa_storage, 0, sizeof(sa_storage));
-  test_eq(sizeof(struct sockaddr_in),
+  tt_int_op(sizeof(struct sockaddr_in),==,
           tor_addr_to_sockaddr(&t1, 1234, (struct sockaddr *)&sa_storage,
                                sizeof(sa_storage)));
-  test_eq(1234, ntohs(sin->sin_port));
-  test_eq(0x7f7f0102, ntohl(sin->sin_addr.s_addr));
+  tt_int_op(1234,==, ntohs(sin->sin_port));
+  tt_int_op(0x7f7f0102,==, ntohl(sin->sin_addr.s_addr));
 
   memset(&sa_storage, 0, sizeof(sa_storage));
   sin6 = (struct sockaddr_in6 *)&sa_storage;
@@ -241,37 +241,37 @@ test_addr_ip6_helpers(void)
   sin6->sin6_port = htons(7070);
   sin6->sin6_addr.s6_addr[0] = 128;
   tor_addr_from_sockaddr(&t1, (struct sockaddr *)sin6, &port1);
-  test_eq(tor_addr_family(&t1), AF_INET6);
+  tt_int_op(tor_addr_family(&t1),==, AF_INET6);
   tt_int_op(port1, ==, 7070);
   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 0);
-  test_streq(p1, "8000::");
+  tt_str_op(p1,==, "8000::");
 
   memset(&sa_storage, 0, sizeof(sa_storage));
-  test_eq(sizeof(struct sockaddr_in6),
+  tt_int_op(sizeof(struct sockaddr_in6),==,
           tor_addr_to_sockaddr(&t1, 9999, (struct sockaddr *)&sa_storage,
                                sizeof(sa_storage)));
-  test_eq(AF_INET6, sin6->sin6_family);
-  test_eq(9999, ntohs(sin6->sin6_port));
-  test_eq(0x80000000, ntohl(S6_ADDR32(sin6->sin6_addr)[0]));
+  tt_int_op(AF_INET6,==, sin6->sin6_family);
+  tt_int_op(9999,==, ntohs(sin6->sin6_port));
+  tt_int_op(0x80000000,==, ntohl(S6_ADDR32(sin6->sin6_addr)[0]));
 
   /* ==== tor_addr_lookup: static cases.  (Can't test dns without knowing we
    * have a good resolver. */
-  test_eq(0, tor_addr_lookup("127.128.129.130", AF_UNSPEC, &t1));
-  test_eq(AF_INET, tor_addr_family(&t1));
-  test_eq(tor_addr_to_ipv4h(&t1), 0x7f808182);
+  tt_int_op(0,==, tor_addr_lookup("127.128.129.130", AF_UNSPEC, &t1));
+  tt_int_op(AF_INET,==, tor_addr_family(&t1));
+  tt_int_op(tor_addr_to_ipv4h(&t1),==, 0x7f808182);
 
-  test_eq(0, tor_addr_lookup("9000::5", AF_UNSPEC, &t1));
-  test_eq(AF_INET6, tor_addr_family(&t1));
-  test_eq(0x90, tor_addr_to_in6_addr8(&t1)[0]);
-  test_assert(tor_mem_is_zero((char*)tor_addr_to_in6_addr8(&t1)+1, 14));
-  test_eq(0x05, tor_addr_to_in6_addr8(&t1)[15]);
+  tt_int_op(0,==, tor_addr_lookup("9000::5", AF_UNSPEC, &t1));
+  tt_int_op(AF_INET6,==, tor_addr_family(&t1));
+  tt_int_op(0x90,==, tor_addr_to_in6_addr8(&t1)[0]);
+  tt_assert(tor_mem_is_zero((char*)tor_addr_to_in6_addr8(&t1)+1, 14));
+  tt_int_op(0x05,==, tor_addr_to_in6_addr8(&t1)[15]);
 
   /* === Test pton: valid af_inet6 */
   /* Simple, valid parsing. */
   r = tor_inet_pton(AF_INET6,
                     "0102:0304:0506:0708:090A:0B0C:0D0E:0F10", &a1);
-  test_assert(r==1);
-  for (i=0;i<16;++i) { test_eq(i+1, (int)a1.s6_addr[i]); }
+  tt_int_op(r, ==, 1);
+  for (i=0;i<16;++i) { tt_int_op(i+1,==, (int)a1.s6_addr[i]); }
   /* ipv4 ending. */
   test_pton6_same("0102:0304:0506:0708:090A:0B0C:0D0E:0F10",
                   "0102:0304:0506:0708:090A:0B0C:13.14.15.16");
@@ -311,7 +311,7 @@ test_addr_ip6_helpers(void)
                      "1000:1:0:7::");
 
   /* Bad af param */
-  test_eq(tor_inet_pton(AF_UNSPEC, 0, 0), -1);
+  tt_int_op(tor_inet_pton(AF_UNSPEC, 0, 0),==, -1);
 
   /* === Test pton: invalid in6. */
   test_pton6_bad("foobar.");
@@ -414,10 +414,10 @@ test_addr_ip6_helpers(void)
   test_addr_compare("0::ffff:5.2.2.1", <, "::ffff:6.0.0.0"); /* XXXX wrong. */
   tor_addr_parse_mask_ports("[::ffff:2.3.4.5]", 0, &t1, NULL, NULL, NULL);
   tor_addr_parse_mask_ports("2.3.4.5", 0, &t2, NULL, NULL, NULL);
-  test_assert(tor_addr_compare(&t1, &t2, CMP_SEMANTIC) == 0);
+  tt_assert(tor_addr_compare(&t1, &t2, CMP_SEMANTIC) == 0);
   tor_addr_parse_mask_ports("[::ffff:2.3.4.4]", 0, &t1, NULL, NULL, NULL);
   tor_addr_parse_mask_ports("2.3.4.5", 0, &t2, NULL, NULL, NULL);
-  test_assert(tor_addr_compare(&t1, &t2, CMP_SEMANTIC) < 0);
+  tt_assert(tor_addr_compare(&t1, &t2, CMP_SEMANTIC) < 0);
 
   /* test compare_masked */
   test_addr_compare_masked("ffff::", ==, "ffff::0", 128);
@@ -426,113 +426,113 @@ test_addr_ip6_helpers(void)
   test_addr_compare_masked("0::2:2:1", ==, "0::8000:2:1", 80);
 
   /* Test undecorated tor_addr_to_str */
-  test_eq(AF_INET6, tor_addr_parse(&t1, "[123:45:6789::5005:11]"));
+  tt_int_op(AF_INET6,==, tor_addr_parse(&t1, "[123:45:6789::5005:11]"));
   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 0);
-  test_streq(p1, "123:45:6789::5005:11");
-  test_eq(AF_INET, tor_addr_parse(&t1, "18.0.0.1"));
+  tt_str_op(p1,==, "123:45:6789::5005:11");
+  tt_int_op(AF_INET,==, tor_addr_parse(&t1, "18.0.0.1"));
   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 0);
-  test_streq(p1, "18.0.0.1");
+  tt_str_op(p1,==, "18.0.0.1");
 
   /* Test decorated tor_addr_to_str */
-  test_eq(AF_INET6, tor_addr_parse(&t1, "[123:45:6789::5005:11]"));
+  tt_int_op(AF_INET6,==, tor_addr_parse(&t1, "[123:45:6789::5005:11]"));
   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
-  test_streq(p1, "[123:45:6789::5005:11]");
-  test_eq(AF_INET, tor_addr_parse(&t1, "18.0.0.1"));
+  tt_str_op(p1,==, "[123:45:6789::5005:11]");
+  tt_int_op(AF_INET,==, tor_addr_parse(&t1, "18.0.0.1"));
   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
-  test_streq(p1, "18.0.0.1");
+  tt_str_op(p1,==, "18.0.0.1");
 
   /* Test buffer bounds checking of tor_addr_to_str */
-  test_eq(AF_INET6, tor_addr_parse(&t1, "::")); /* 2 + \0 */
-  test_eq_ptr(tor_addr_to_str(buf, &t1, 2, 0), NULL); /* too short buf */
-  test_streq(tor_addr_to_str(buf, &t1, 3, 0), "::");
-  test_eq_ptr(tor_addr_to_str(buf, &t1, 4, 1), NULL); /* too short buf */
-  test_streq(tor_addr_to_str(buf, &t1, 5, 1), "[::]");
+  tt_int_op(AF_INET6,==, tor_addr_parse(&t1, "::")); /* 2 + \0 */
+  tt_ptr_op(tor_addr_to_str(buf, &t1, 2, 0),==, NULL); /* too short buf */
+  tt_str_op(tor_addr_to_str(buf, &t1, 3, 0),==, "::");
+  tt_ptr_op(tor_addr_to_str(buf, &t1, 4, 1),==, NULL); /* too short buf */
+  tt_str_op(tor_addr_to_str(buf, &t1, 5, 1),==, "[::]");
 
-  test_eq(AF_INET6, tor_addr_parse(&t1, "2000::1337")); /* 10 + \0 */
-  test_eq_ptr(tor_addr_to_str(buf, &t1, 10, 0), NULL); /* too short buf */
-  test_streq(tor_addr_to_str(buf, &t1, 11, 0), "2000::1337");
-  test_eq_ptr(tor_addr_to_str(buf, &t1, 12, 1), NULL); /* too short buf */
-  test_streq(tor_addr_to_str(buf, &t1, 13, 1), "[2000::1337]");
+  tt_int_op(AF_INET6,==, tor_addr_parse(&t1, "2000::1337")); /* 10 + \0 */
+  tt_ptr_op(tor_addr_to_str(buf, &t1, 10, 0),==, NULL); /* too short buf */
+  tt_str_op(tor_addr_to_str(buf, &t1, 11, 0),==, "2000::1337");
+  tt_ptr_op(tor_addr_to_str(buf, &t1, 12, 1),==, NULL); /* too short buf */
+  tt_str_op(tor_addr_to_str(buf, &t1, 13, 1),==, "[2000::1337]");
 
-  test_eq(AF_INET, tor_addr_parse(&t1, "1.2.3.4")); /* 7 + \0 */
-  test_eq_ptr(tor_addr_to_str(buf, &t1, 7, 0), NULL); /* too short buf */
-  test_streq(tor_addr_to_str(buf, &t1, 8, 0), "1.2.3.4");
+  tt_int_op(AF_INET,==, tor_addr_parse(&t1, "1.2.3.4")); /* 7 + \0 */
+  tt_ptr_op(tor_addr_to_str(buf, &t1, 7, 0),==, NULL); /* too short buf */
+  tt_str_op(tor_addr_to_str(buf, &t1, 8, 0),==, "1.2.3.4");
 
-  test_eq(AF_INET, tor_addr_parse(&t1, "255.255.255.255")); /* 15 + \0 */
-  test_eq_ptr(tor_addr_to_str(buf, &t1, 15, 0), NULL); /* too short buf */
-  test_streq(tor_addr_to_str(buf, &t1, 16, 0), "255.255.255.255");
-  test_eq_ptr(tor_addr_to_str(buf, &t1, 15, 1), NULL); /* too short buf */
-  test_streq(tor_addr_to_str(buf, &t1, 16, 1), "255.255.255.255");
+  tt_int_op(AF_INET,==, tor_addr_parse(&t1, "255.255.255.255")); /* 15 + \0 */
+  tt_ptr_op(tor_addr_to_str(buf, &t1, 15, 0),==, NULL); /* too short buf */
+  tt_str_op(tor_addr_to_str(buf, &t1, 16, 0),==, "255.255.255.255");
+  tt_ptr_op(tor_addr_to_str(buf, &t1, 15, 1),==, NULL); /* too short buf */
+  tt_str_op(tor_addr_to_str(buf, &t1, 16, 1),==, "255.255.255.255");
 
   t1.family = AF_UNSPEC;
-  test_eq_ptr(tor_addr_to_str(buf, &t1, sizeof(buf), 0), NULL);
+  tt_ptr_op(tor_addr_to_str(buf, &t1, sizeof(buf), 0),==, NULL);
 
   /* Test tor_addr_parse_PTR_name */
   i = tor_addr_parse_PTR_name(&t1, "Foobar.baz", AF_UNSPEC, 0);
-  test_eq(0, i);
+  tt_int_op(0,==, i);
   i = tor_addr_parse_PTR_name(&t1, "Foobar.baz", AF_UNSPEC, 1);
-  test_eq(0, i);
+  tt_int_op(0,==, i);
   i = tor_addr_parse_PTR_name(&t1, "9999999999999999999999999999.in-addr.arpa",
                               AF_UNSPEC, 1);
-  test_eq(-1, i);
+  tt_int_op(-1,==, i);
   i = tor_addr_parse_PTR_name(&t1, "1.0.168.192.in-addr.arpa",
                                          AF_UNSPEC, 1);
-  test_eq(1, i);
-  test_eq(tor_addr_family(&t1), AF_INET);
+  tt_int_op(1,==, i);
+  tt_int_op(tor_addr_family(&t1),==, AF_INET);
   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
-  test_streq(p1, "192.168.0.1");
+  tt_str_op(p1,==, "192.168.0.1");
   i = tor_addr_parse_PTR_name(&t1, "192.168.0.99", AF_UNSPEC, 0);
-  test_eq(0, i);
+  tt_int_op(0,==, i);
   i = tor_addr_parse_PTR_name(&t1, "192.168.0.99", AF_UNSPEC, 1);
-  test_eq(1, i);
+  tt_int_op(1,==, i);
   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
-  test_streq(p1, "192.168.0.99");
+  tt_str_op(p1,==, "192.168.0.99");
   memset(&t1, 0, sizeof(t1));
   i = tor_addr_parse_PTR_name(&t1,
                                          "0.1.2.3.4.5.6.7.8.9.a.b.c.d.e.f."
                                          "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9."
                                          "ip6.ARPA",
                                          AF_UNSPEC, 0);
-  test_eq(1, i);
+  tt_int_op(1,==, i);
   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
-  test_streq(p1, "[9dee:effe:ebe1:beef:fedc:ba98:7654:3210]");
+  tt_str_op(p1,==, "[9dee:effe:ebe1:beef:fedc:ba98:7654:3210]");
   /* Failing cases. */
   i = tor_addr_parse_PTR_name(&t1,
                                          "6.7.8.9.a.b.c.d.e.f."
                                          "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9."
                                          "ip6.ARPA",
                                          AF_UNSPEC, 0);
-  test_eq(i, -1);
+  tt_int_op(i,==, -1);
   i = tor_addr_parse_PTR_name(&t1,
                                          "6.7.8.9.a.b.c.d.e.f.a.b.c.d.e.f.0."
                                          "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9."
                                          "ip6.ARPA",
                                          AF_UNSPEC, 0);
-  test_eq(i, -1);
+  tt_int_op(i,==, -1);
   i = tor_addr_parse_PTR_name(&t1,
                                          "6.7.8.9.a.b.c.d.e.f.X.0.0.0.0.9."
                                          "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9."
                                          "ip6.ARPA",
                                          AF_UNSPEC, 0);
-  test_eq(i, -1);
+  tt_int_op(i,==, -1);
   i = tor_addr_parse_PTR_name(&t1, "32.1.1.in-addr.arpa",
                                          AF_UNSPEC, 0);
-  test_eq(i, -1);
+  tt_int_op(i,==, -1);
   i = tor_addr_parse_PTR_name(&t1, ".in-addr.arpa",
                                          AF_UNSPEC, 0);
-  test_eq(i, -1);
+  tt_int_op(i,==, -1);
   i = tor_addr_parse_PTR_name(&t1, "1.2.3.4.5.in-addr.arpa",
                                          AF_UNSPEC, 0);
-  test_eq(i, -1);
+  tt_int_op(i,==, -1);
   i = tor_addr_parse_PTR_name(&t1, "1.2.3.4.5.in-addr.arpa",
                                          AF_INET6, 0);
-  test_eq(i, -1);
+  tt_int_op(i,==, -1);
   i = tor_addr_parse_PTR_name(&t1,
                                          "6.7.8.9.a.b.c.d.e.f.a.b.c.d.e.0."
                                          "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9."
                                          "ip6.ARPA",
                                          AF_INET, 0);
-  test_eq(i, -1);
+  tt_int_op(i,==, -1);
 
   /* === Test tor_addr_to_PTR_name */
 
@@ -544,19 +544,19 @@ test_addr_ip6_helpers(void)
   tor_addr_from_sockaddr(&t1, (struct sockaddr *)sin, NULL);
 
   /* Check IPv4 PTR - too short buffer */
-  test_eq(tor_addr_to_PTR_name(rbuf, 1, &t1), -1);
-  test_eq(tor_addr_to_PTR_name(rbuf,
+  tt_int_op(tor_addr_to_PTR_name(rbuf, 1, &t1),==, -1);
+  tt_int_op(tor_addr_to_PTR_name(rbuf,
                                strlen("3.2.1.127.in-addr.arpa") - 1,
-                               &t1), -1);
+                               &t1),==, -1);
 
   /* Check IPv4 PTR - valid addr */
-  test_eq(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),
+  tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),==,
           strlen("3.2.1.127.in-addr.arpa"));
-  test_streq(rbuf, "3.2.1.127.in-addr.arpa");
+  tt_str_op(rbuf,==, "3.2.1.127.in-addr.arpa");
 
   /* Invalid addr family */
   t1.family = AF_UNSPEC;
-  test_eq(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1), -1);
+  tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),==, -1);
 
   /* Stage IPv6 addr */
   memset(&sa_storage, 0, sizeof(sa_storage));
@@ -573,81 +573,81 @@ test_addr_ip6_helpers(void)
       "0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.ip6.arpa";
 
     /* Check IPv6 PTR - too short buffer */
-    test_eq(tor_addr_to_PTR_name(rbuf, 0, &t1), -1);
-    test_eq(tor_addr_to_PTR_name(rbuf, strlen(addr_PTR) - 1, &t1), -1);
+    tt_int_op(tor_addr_to_PTR_name(rbuf, 0, &t1),==, -1);
+    tt_int_op(tor_addr_to_PTR_name(rbuf, strlen(addr_PTR) - 1, &t1),==, -1);
 
     /* Check IPv6 PTR - valid addr */
-    test_eq(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),
+    tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),==,
             strlen(addr_PTR));
-    test_streq(rbuf, addr_PTR);
+    tt_str_op(rbuf,==, addr_PTR);
   }
 
   /* XXXX turn this into a separate function; it's not all IPv6. */
   /* test tor_addr_parse_mask_ports */
   test_addr_mask_ports_parse("[::f]/17:47-95", AF_INET6,
                              0, 0, 0, 0x0000000f, 17, 47, 95);
-  test_streq(p1, "::f");
+  tt_str_op(p1,==, "::f");
   //test_addr_parse("[::fefe:4.1.1.7/120]:999-1000");
   //test_addr_parse_check("::fefe:401:107", 120, 999, 1000);
   test_addr_mask_ports_parse("[::ffff:4.1.1.7]/120:443", AF_INET6,
                              0, 0, 0x0000ffff, 0x04010107, 120, 443, 443);
-  test_streq(p1, "::ffff:4.1.1.7");
+  tt_str_op(p1,==, "::ffff:4.1.1.7");
   test_addr_mask_ports_parse("[abcd:2::44a:0]:2-65000", AF_INET6,
                              0xabcd0002, 0, 0, 0x044a0000, 128, 2, 65000);
 
-  test_streq(p1, "abcd:2::44a:0");
+  tt_str_op(p1,==, "abcd:2::44a:0");
   /* Try some long addresses. */
   r=tor_addr_parse_mask_ports("[ffff:1111:1111:1111:1111:1111:1111:1111]",
                               0, &t1, NULL, NULL, NULL);
-  test_assert(r == AF_INET6);
+  tt_assert(r == AF_INET6);
   r=tor_addr_parse_mask_ports("[ffff:1111:1111:1111:1111:1111:1111:11111]",
                               0, &t1, NULL, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   r=tor_addr_parse_mask_ports("[ffff:1111:1111:1111:1111:1111:1111:1111:1]",
                               0, &t1, NULL, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   r=tor_addr_parse_mask_ports(
          "[ffff:1111:1111:1111:1111:1111:1111:ffff:"
          "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:"
          "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:"
          "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]",
          0, &t1, NULL, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   /* Try some failing cases. */
   r=tor_addr_parse_mask_ports("[fefef::]/112", 0, &t1, NULL, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   r=tor_addr_parse_mask_ports("[fefe::/112", 0, &t1, NULL, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   r=tor_addr_parse_mask_ports("[fefe::", 0, &t1, NULL, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   r=tor_addr_parse_mask_ports("[fefe::X]", 0, &t1, NULL, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   r=tor_addr_parse_mask_ports("efef::/112", 0, &t1, NULL, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   r=tor_addr_parse_mask_ports("[f:f:f:f:f:f:f:f::]",0,&t1, NULL, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   r=tor_addr_parse_mask_ports("[::f:f:f:f:f:f:f:f]",0,&t1, NULL, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   r=tor_addr_parse_mask_ports("[f:f:f:f:f:f:f:f:f]",0,&t1, NULL, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   r=tor_addr_parse_mask_ports("[f:f:f:f:f::]/fred",0,&t1,&mask, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   r=tor_addr_parse_mask_ports("[f:f:f:f:f::]/255.255.0.0",
                               0,&t1, NULL, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   /* This one will get rejected because it isn't a pure prefix. */
   r=tor_addr_parse_mask_ports("1.1.2.3/255.255.64.0",0,&t1, &mask,NULL,NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   /* Test for V4-mapped address with mask < 96.  (arguably not valid) */
   r=tor_addr_parse_mask_ports("[::ffff:1.1.2.2/33]",0,&t1, &mask, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   r=tor_addr_parse_mask_ports("1.1.2.2/33",0,&t1, &mask, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   /* Try extended wildcard addresses with out TAPMP_EXTENDED_STAR*/
   r=tor_addr_parse_mask_ports("*4",0,&t1, &mask, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   r=tor_addr_parse_mask_ports("*6",0,&t1, &mask, NULL, NULL);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
 #if 0
   /* Try a mask with a wildcard. */
   r=tor_addr_parse_mask_ports("*/16",0,&t1, &mask, NULL, NULL);
@@ -661,26 +661,26 @@ test_addr_ip6_helpers(void)
 #endif
   /* Basic mask tests*/
   r=tor_addr_parse_mask_ports("1.1.2.2/31",0,&t1, &mask, NULL, NULL);
-  test_assert(r == AF_INET);
+  tt_assert(r == AF_INET);
   tt_int_op(mask,==,31);
   tt_int_op(tor_addr_family(&t1),==,AF_INET);
   tt_int_op(tor_addr_to_ipv4h(&t1),==,0x01010202);
   r=tor_addr_parse_mask_ports("3.4.16.032:1-2",0,&t1, &mask, &port1, &port2);
-  test_assert(r == AF_INET);
+  tt_assert(r == AF_INET);
   tt_int_op(mask,==,32);
   tt_int_op(tor_addr_family(&t1),==,AF_INET);
   tt_int_op(tor_addr_to_ipv4h(&t1),==,0x03041020);
-  test_assert(port1 == 1);
-  test_assert(port2 == 2);
+  tt_assert(port1 == 1);
+  tt_assert(port2 == 2);
   r=tor_addr_parse_mask_ports("1.1.2.3/255.255.128.0",0,&t1, &mask,NULL,NULL);
-  test_assert(r == AF_INET);
+  tt_assert(r == AF_INET);
   tt_int_op(mask,==,17);
   tt_int_op(tor_addr_family(&t1),==,AF_INET);
   tt_int_op(tor_addr_to_ipv4h(&t1),==,0x01010203);
   r=tor_addr_parse_mask_ports("[efef::]/112",0,&t1, &mask, &port1, &port2);
-  test_assert(r == AF_INET6);
-  test_assert(port1 == 1);
-  test_assert(port2 == 65535);
+  tt_assert(r == AF_INET6);
+  tt_assert(port1 == 1);
+  tt_assert(port2 == 65535);
   /* Try regular wildcard behavior without TAPMP_EXTENDED_STAR */
   r=tor_addr_parse_mask_ports("*:80-443",0,&t1,&mask,&port1,&port2);
   tt_int_op(r,==,AF_INET); /* Old users of this always get inet */
@@ -715,11 +715,11 @@ test_addr_ip6_helpers(void)
   tt_int_op(port2,==,65535);
 
   /* make sure inet address lengths >= max */
-  test_assert(INET_NTOA_BUF_LEN >= sizeof("255.255.255.255"));
-  test_assert(TOR_ADDR_BUF_LEN >=
+  tt_assert(INET_NTOA_BUF_LEN >= sizeof("255.255.255.255"));
+  tt_assert(TOR_ADDR_BUF_LEN >=
               sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"));
 
-  test_assert(sizeof(tor_addr_t) >= sizeof(struct in6_addr));
+  tt_assert(sizeof(tor_addr_t) >= sizeof(struct in6_addr));
 
   /* get interface addresses */
   r = get_interface_address6(LOG_DEBUG, AF_INET, &t1);
@@ -747,86 +747,86 @@ test_addr_parse(void)
   r= tor_addr_port_parse(LOG_DEBUG,
                          "192.0.2.1:1234",
                          &addr, &port, -1);
-  test_assert(r == 0);
+  tt_int_op(r, ==, 0);
   tor_addr_to_str(buf, &addr, sizeof(buf), 0);
-  test_streq(buf, "192.0.2.1");
-  test_eq(port, 1234);
+  tt_str_op(buf,==, "192.0.2.1");
+  tt_int_op(port,==, 1234);
 
   r= tor_addr_port_parse(LOG_DEBUG,
                          "[::1]:1234",
                          &addr, &port, -1);
-  test_assert(r == 0);
+  tt_int_op(r, ==, 0);
   tor_addr_to_str(buf, &addr, sizeof(buf), 0);
-  test_streq(buf, "::1");
-  test_eq(port, 1234);
+  tt_str_op(buf,==, "::1");
+  tt_int_op(port,==, 1234);
 
   /* Domain name. */
   r= tor_addr_port_parse(LOG_DEBUG,
                          "torproject.org:1234",
                          &addr, &port, -1);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
 
   /* Only IP. */
   r= tor_addr_port_parse(LOG_DEBUG,
                          "192.0.2.2",
                          &addr, &port, -1);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
 
   r= tor_addr_port_parse(LOG_DEBUG,
                          "192.0.2.2",
                          &addr, &port, 200);
-  test_assert(r == 0);
+  tt_int_op(r, ==, 0);
   tt_int_op(port,==,200);
 
   r= tor_addr_port_parse(LOG_DEBUG,
                          "[::1]",
                          &addr, &port, -1);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
 
   r= tor_addr_port_parse(LOG_DEBUG,
                          "[::1]",
                          &addr, &port, 400);
-  test_assert(r == 0);
+  tt_int_op(r, ==, 0);
   tt_int_op(port,==,400);
 
   /* Bad port. */
   r= tor_addr_port_parse(LOG_DEBUG,
                          "192.0.2.2:66666",
                          &addr, &port, -1);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   r= tor_addr_port_parse(LOG_DEBUG,
                          "192.0.2.2:66666",
                          &addr, &port, 200);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
 
   /* Only domain name */
   r= tor_addr_port_parse(LOG_DEBUG,
                          "torproject.org",
                          &addr, &port, -1);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
   r= tor_addr_port_parse(LOG_DEBUG,
                          "torproject.org",
                          &addr, &port, 200);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
 
   /* Bad IP address */
   r= tor_addr_port_parse(LOG_DEBUG,
                          "192.0.2:1234",
                          &addr, &port, -1);
-  test_assert(r == -1);
+  tt_int_op(r, ==, -1);
 
   /* Make sure that the default port has lower priority than the real
      one */
   r= tor_addr_port_parse(LOG_DEBUG,
                          "192.0.2.2:1337",
                          &addr, &port, 200);
-  test_assert(r == 0);
+  tt_int_op(r, ==, 0);
   tt_int_op(port,==,1337);
 
   r= tor_addr_port_parse(LOG_DEBUG,
                          "[::1]:1369",
                          &addr, &port, 200);
-  test_assert(r == 0);
+  tt_int_op(r, ==, 0);
   tt_int_op(port,==,1369);
 
  done:
diff --git a/src/test/test_buffers.c b/src/test/test_buffers.c
index f24b80f0b0..3ab3d8d8c0 100644
--- a/src/test/test_buffers.c
+++ b/src/test/test_buffers.c
@@ -27,10 +27,10 @@ test_buffers_basic(void *arg)
    * buf_new
    ****/
   if (!(buf = buf_new()))
-    test_fail();
+    TT_DIE(("Assertion failed."));
 
   //test_eq(buf_capacity(buf), 4096);
-  test_eq(buf_datalen(buf), 0);
+  tt_int_op(buf_datalen(buf),==, 0);
 
   /****
    * General pointer frobbing
@@ -40,16 +40,16 @@ test_buffers_basic(void *arg)
   }
   write_to_buf(str, 256, buf);
   write_to_buf(str, 256, buf);
-  test_eq(buf_datalen(buf), 512);
+  tt_int_op(buf_datalen(buf),==, 512);
   fetch_from_buf(str2, 200, buf);
-  test_memeq(str, str2, 200);
-  test_eq(buf_datalen(buf), 312);
+  tt_mem_op(str,==, str2, 200);
+  tt_int_op(buf_datalen(buf),==, 312);
   memset(str2, 0, sizeof(str2));
 
   fetch_from_buf(str2, 256, buf);
-  test_memeq(str+200, str2, 56);
-  test_memeq(str, str2+56, 200);
-  test_eq(buf_datalen(buf), 56);
+  tt_mem_op(str+200,==, str2, 56);
+  tt_mem_op(str,==, str2+56, 200);
+  tt_int_op(buf_datalen(buf),==, 56);
   memset(str2, 0, sizeof(str2));
   /* Okay, now we should be 512 bytes into the 4096-byte buffer.  If we add
    * another 3584 bytes, we hit the end. */
@@ -57,16 +57,16 @@ test_buffers_basic(void *arg)
     write_to_buf(str, 256, buf);
   }
   assert_buf_ok(buf);
-  test_eq(buf_datalen(buf), 3896);
+  tt_int_op(buf_datalen(buf),==, 3896);
   fetch_from_buf(str2, 56, buf);
-  test_eq(buf_datalen(buf), 3840);
-  test_memeq(str+200, str2, 56);
+  tt_int_op(buf_datalen(buf),==, 3840);
+  tt_mem_op(str+200,==, str2, 56);
   for (j=0;j<15;++j) {
     memset(str2, 0, sizeof(str2));
     fetch_from_buf(str2, 256, buf);
-    test_memeq(str, str2, 256);
+    tt_mem_op(str,==, str2, 256);
   }
-  test_eq(buf_datalen(buf), 0);
+  tt_int_op(buf_datalen(buf),==, 0);
   buf_free(buf);
   buf = NULL;
 
@@ -76,7 +76,7 @@ test_buffers_basic(void *arg)
   write_to_buf(str+1, 255, buf);
   //test_eq(buf_capacity(buf), 256);
   fetch_from_buf(str2, 254, buf);
-  test_memeq(str+1, str2, 254);
+  tt_mem_op(str+1,==, str2, 254);
   //test_eq(buf_capacity(buf), 256);
   assert_buf_ok(buf);
   write_to_buf(str, 32, buf);
@@ -85,15 +85,15 @@ test_buffers_basic(void *arg)
   write_to_buf(str, 256, buf);
   assert_buf_ok(buf);
   //test_eq(buf_capacity(buf), 512);
-  test_eq(buf_datalen(buf), 33+256);
+  tt_int_op(buf_datalen(buf),==, 33+256);
   fetch_from_buf(str2, 33, buf);
-  test_eq(*str2, str[255]);
+  tt_int_op(*str2,==, str[255]);
 
-  test_memeq(str2+1, str, 32);
+  tt_mem_op(str2+1,==, str, 32);
   //test_eq(buf_capacity(buf), 512);
-  test_eq(buf_datalen(buf), 256);
+  tt_int_op(buf_datalen(buf),==, 256);
   fetch_from_buf(str2, 256, buf);
-  test_memeq(str, str2, 256);
+  tt_mem_op(str,==, str2, 256);
 
   /* now try shrinking: case 1. */
   buf_free(buf);
@@ -102,10 +102,10 @@ test_buffers_basic(void *arg)
     write_to_buf(str,255, buf);
   }
   //test_eq(buf_capacity(buf), 33668);
-  test_eq(buf_datalen(buf), 17085);
+  tt_int_op(buf_datalen(buf),==, 17085);
   for (j=0; j < 40; ++j) {
     fetch_from_buf(str2, 255,buf);
-    test_memeq(str2, str, 255);
+    tt_mem_op(str2,==, str, 255);
   }
 
   /* now try shrinking: case 2. */
@@ -116,7 +116,7 @@ test_buffers_basic(void *arg)
   }
   for (j=0; j < 20; ++j) {
     fetch_from_buf(str2, 255,buf);
-    test_memeq(str2, str, 255);
+    tt_mem_op(str2,==, str, 255);
   }
   for (j=0;j<80;++j) {
     write_to_buf(str,255, buf);
@@ -124,7 +124,7 @@ test_buffers_basic(void *arg)
   //test_eq(buf_capacity(buf),33668);
   for (j=0; j < 120; ++j) {
     fetch_from_buf(str2, 255,buf);
-    test_memeq(str2, str, 255);
+    tt_mem_op(str2,==, str, 255);
   }
 
   /* Move from buf to buf. */
@@ -133,27 +133,27 @@ test_buffers_basic(void *arg)
   buf2 = buf_new_with_capacity(4096);
   for (j=0;j<100;++j)
     write_to_buf(str, 255, buf);
-  test_eq(buf_datalen(buf), 25500);
+  tt_int_op(buf_datalen(buf),==, 25500);
   for (j=0;j<100;++j) {
     r = 10;
     move_buf_to_buf(buf2, buf, &r);
-    test_eq(r, 0);
+    tt_int_op(r,==, 0);
   }
-  test_eq(buf_datalen(buf), 24500);
-  test_eq(buf_datalen(buf2), 1000);
+  tt_int_op(buf_datalen(buf),==, 24500);
+  tt_int_op(buf_datalen(buf2),==, 1000);
   for (j=0;j<3;++j) {
     fetch_from_buf(str2, 255, buf2);
-    test_memeq(str2, str, 255);
+    tt_mem_op(str2,==, str, 255);
   }
   r = 8192; /*big move*/
   move_buf_to_buf(buf2, buf, &r);
-  test_eq(r, 0);
+  tt_int_op(r,==, 0);
   r = 30000; /* incomplete move */
   move_buf_to_buf(buf2, buf, &r);
-  test_eq(r, 13692);
+  tt_int_op(r,==, 13692);
   for (j=0;j<97;++j) {
     fetch_from_buf(str2, 255, buf2);
-    test_memeq(str2, str, 255);
+    tt_mem_op(str2,==, str, 255);
   }
   buf_free(buf);
   buf_free(buf2);
@@ -163,16 +163,16 @@ test_buffers_basic(void *arg)
   cp = "Testing. This is a moderately long Testing string.";
   for (j = 0; cp[j]; j++)
     write_to_buf(cp+j, 1, buf);
-  test_eq(0, buf_find_string_offset(buf, "Testing", 7));
-  test_eq(1, buf_find_string_offset(buf, "esting", 6));
-  test_eq(1, buf_find_string_offset(buf, "est", 3));
-  test_eq(39, buf_find_string_offset(buf, "ing str", 7));
-  test_eq(35, buf_find_string_offset(buf, "Testing str", 11));
-  test_eq(32, buf_find_string_offset(buf, "ng ", 3));
-  test_eq(43, buf_find_string_offset(buf, "string.", 7));
-  test_eq(-1, buf_find_string_offset(buf, "shrdlu", 6));
-  test_eq(-1, buf_find_string_offset(buf, "Testing thing", 13));
-  test_eq(-1, buf_find_string_offset(buf, "ngx", 3));
+  tt_int_op(0,==, buf_find_string_offset(buf, "Testing", 7));
+  tt_int_op(1,==, buf_find_string_offset(buf, "esting", 6));
+  tt_int_op(1,==, buf_find_string_offset(buf, "est", 3));
+  tt_int_op(39,==, buf_find_string_offset(buf, "ing str", 7));
+  tt_int_op(35,==, buf_find_string_offset(buf, "Testing str", 11));
+  tt_int_op(32,==, buf_find_string_offset(buf, "ng ", 3));
+  tt_int_op(43,==, buf_find_string_offset(buf, "string.", 7));
+  tt_int_op(-1,==, buf_find_string_offset(buf, "shrdlu", 6));
+  tt_int_op(-1,==, buf_find_string_offset(buf, "Testing thing", 13));
+  tt_int_op(-1,==, buf_find_string_offset(buf, "ngx", 3));
   buf_free(buf);
   buf = NULL;
 
@@ -240,16 +240,16 @@ test_buffer_pullup(void *arg)
   /* Make room for 3000 bytes in the first chunk, so that the pullup-move code
    * can get tested. */
   tt_int_op(fetch_from_buf(tmp, 3000, buf), ==, 3000);
-  test_memeq(tmp, stuff, 3000);
+  tt_mem_op(tmp,==, stuff, 3000);
   buf_pullup(buf, 2048, 0);
   assert_buf_ok(buf);
   buf_get_first_chunk_data(buf, &cp, &sz);
   tt_ptr_op(cp, !=, NULL);
   tt_int_op(sz, >=, 2048);
-  test_memeq(cp, stuff+3000, 2048);
+  tt_mem_op(cp,==, stuff+3000, 2048);
   tt_int_op(3000, ==, buf_datalen(buf));
   tt_int_op(fetch_from_buf(tmp, 3000, buf), ==, 0);
-  test_memeq(tmp, stuff+3000, 2048);
+  tt_mem_op(tmp,==, stuff+3000, 2048);
 
   buf_free(buf);
 
@@ -269,16 +269,16 @@ test_buffer_pullup(void *arg)
   buf_get_first_chunk_data(buf, &cp, &sz);
   tt_ptr_op(cp, !=, NULL);
   tt_int_op(sz, >=, 12500);
-  test_memeq(cp, stuff, 12500);
+  tt_mem_op(cp,==, stuff, 12500);
   tt_int_op(buf_datalen(buf), ==, 16000);
 
   fetch_from_buf(tmp, 12400, buf);
-  test_memeq(tmp, stuff, 12400);
+  tt_mem_op(tmp,==, stuff, 12400);
   tt_int_op(buf_datalen(buf), ==, 3600);
   fetch_from_buf(tmp, 3500, buf);
-  test_memeq(tmp, stuff+12400, 3500);
+  tt_mem_op(tmp,==, stuff+12400, 3500);
   fetch_from_buf(tmp, 100, buf);
-  test_memeq(tmp, stuff+15900, 10);
+  tt_mem_op(tmp,==, stuff+15900, 10);
 
   buf_free(buf);
 
@@ -292,7 +292,7 @@ test_buffer_pullup(void *arg)
   buf_get_first_chunk_data(buf, &cp, &sz);
   tt_ptr_op(cp, !=, NULL);
   tt_int_op(sz, ==, 7900);
-  test_memeq(cp, stuff+100, 7900);
+  tt_mem_op(cp,==, stuff+100, 7900);
 
   buf_free(buf);
   buf = NULL;
@@ -335,14 +335,14 @@ test_buffer_copy(void *arg)
   tt_int_op(0, ==, generic_buffer_set_to_copy(&buf2, buf));
   tt_int_op(len, ==, generic_buffer_len(buf2));
   generic_buffer_get(buf2, b, len);
-  test_mem_op(b, ==, s, len);
+  tt_mem_op(b, ==, s, len);
   /* Now free buf2 and retry so we can test allocating */
   generic_buffer_free(buf2);
   buf2 = NULL;
   tt_int_op(0, ==, generic_buffer_set_to_copy(&buf2, buf));
   tt_int_op(len, ==, generic_buffer_len(buf2));
   generic_buffer_get(buf2, b, len);
-  test_mem_op(b, ==, s, len);
+  tt_mem_op(b, ==, s, len);
   /* Clear buf for next test */
   generic_buffer_get(buf, b, len);
   tt_int_op(generic_buffer_len(buf),==,0);
@@ -362,7 +362,7 @@ test_buffer_copy(void *arg)
   for (i = 0; i < 256; ++i) {
     generic_buffer_get(buf2, b, len+1);
     tt_int_op((unsigned char)b[0],==,i);
-    test_mem_op(b+1, ==, s, len);
+    tt_mem_op(b+1, ==, s, len);
   }
 
  done:
@@ -410,7 +410,7 @@ test_buffer_ext_or_cmd(void *arg)
   tt_ptr_op(NULL, !=, cmd);
   tt_int_op(0x1021, ==, cmd->cmd);
   tt_int_op(6, ==, cmd->len);
-  test_mem_op("abcdef", ==, cmd->body, 6);
+  tt_mem_op("abcdef", ==, cmd->body, 6);
   tt_int_op(0, ==, generic_buffer_len(buf));
   ext_or_cmd_free(cmd);
   cmd = NULL;
@@ -422,7 +422,7 @@ test_buffer_ext_or_cmd(void *arg)
   tt_ptr_op(NULL, !=, cmd);
   tt_int_op(0xffff, ==, cmd->cmd);
   tt_int_op(10, ==, cmd->len);
-  test_mem_op("loremipsum", ==, cmd->body, 10);
+  tt_mem_op("loremipsum", ==, cmd->body, 10);
   tt_int_op(4, ==, generic_buffer_len(buf));
   ext_or_cmd_free(cmd);
   cmd = NULL;
@@ -436,7 +436,7 @@ test_buffer_ext_or_cmd(void *arg)
   tt_ptr_op(NULL, !=, cmd);
   tt_int_op(0x1000, ==, cmd->cmd);
   tt_int_op(0xffff, ==, cmd->len);
-  test_mem_op(tmp, ==, cmd->body, 65535);
+  tt_mem_op(tmp, ==, cmd->body, 65535);
   tt_int_op(0, ==, generic_buffer_len(buf));
   ext_or_cmd_free(cmd);
   cmd = NULL;
diff --git a/src/test/test_cell_formats.c b/src/test/test_cell_formats.c
index d7f60680c2..995e519163 100644
--- a/src/test/test_cell_formats.c
+++ b/src/test/test_cell_formats.c
@@ -35,11 +35,11 @@ test_cfmt_relay_header(void *arg)
   tt_int_op(rh.command, ==, 3);
   tt_int_op(rh.recognized, ==, 0);
   tt_int_op(rh.stream_id, ==, 0x2122);
-  test_mem_op(rh.integrity, ==, "ABCD", 4);
+  tt_mem_op(rh.integrity, ==, "ABCD", 4);
   tt_int_op(rh.length, ==, 0x103);
 
   relay_header_pack(hdr_out, &rh);
-  test_mem_op(hdr_out, ==, hdr_1, RELAY_HEADER_SIZE);
+  tt_mem_op(hdr_out, ==, hdr_1, RELAY_HEADER_SIZE);
 
  done:
   ;
@@ -402,10 +402,10 @@ test_cfmt_create_cells(void *arg)
   tt_int_op(CELL_CREATE, ==, cc.cell_type);
   tt_int_op(ONION_HANDSHAKE_TYPE_TAP, ==, cc.handshake_type);
   tt_int_op(TAP_ONIONSKIN_CHALLENGE_LEN, ==, cc.handshake_len);
-  test_memeq(cc.onionskin, b, TAP_ONIONSKIN_CHALLENGE_LEN + 10);
+  tt_mem_op(cc.onionskin,==, b, TAP_ONIONSKIN_CHALLENGE_LEN + 10);
   tt_int_op(0, ==, create_cell_format(&cell2, &cc));
   tt_int_op(cell.command, ==, cell2.command);
-  test_memeq(cell.payload, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
 
   /* A valid create_fast cell. */
   memset(&cell, 0, sizeof(cell));
@@ -417,10 +417,10 @@ test_cfmt_create_cells(void *arg)
   tt_int_op(CELL_CREATE_FAST, ==, cc.cell_type);
   tt_int_op(ONION_HANDSHAKE_TYPE_FAST, ==, cc.handshake_type);
   tt_int_op(CREATE_FAST_LEN, ==, cc.handshake_len);
-  test_memeq(cc.onionskin, b, CREATE_FAST_LEN + 10);
+  tt_mem_op(cc.onionskin,==, b, CREATE_FAST_LEN + 10);
   tt_int_op(0, ==, create_cell_format(&cell2, &cc));
   tt_int_op(cell.command, ==, cell2.command);
-  test_memeq(cell.payload, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
 
   /* A valid create2 cell with a TAP payload */
   memset(&cell, 0, sizeof(cell));
@@ -433,10 +433,10 @@ test_cfmt_create_cells(void *arg)
   tt_int_op(CELL_CREATE2, ==, cc.cell_type);
   tt_int_op(ONION_HANDSHAKE_TYPE_TAP, ==, cc.handshake_type);
   tt_int_op(TAP_ONIONSKIN_CHALLENGE_LEN, ==, cc.handshake_len);
-  test_memeq(cc.onionskin, b, TAP_ONIONSKIN_CHALLENGE_LEN + 10);
+  tt_mem_op(cc.onionskin,==, b, TAP_ONIONSKIN_CHALLENGE_LEN + 10);
   tt_int_op(0, ==, create_cell_format(&cell2, &cc));
   tt_int_op(cell.command, ==, cell2.command);
-  test_memeq(cell.payload, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
 
   /* A valid create2 cell with an ntor payload */
   memset(&cell, 0, sizeof(cell));
@@ -450,10 +450,10 @@ test_cfmt_create_cells(void *arg)
   tt_int_op(CELL_CREATE2, ==, cc.cell_type);
   tt_int_op(ONION_HANDSHAKE_TYPE_NTOR, ==, cc.handshake_type);
   tt_int_op(NTOR_ONIONSKIN_LEN, ==, cc.handshake_len);
-  test_memeq(cc.onionskin, b, NTOR_ONIONSKIN_LEN + 10);
+  tt_mem_op(cc.onionskin,==, b, NTOR_ONIONSKIN_LEN + 10);
   tt_int_op(0, ==, create_cell_format(&cell2, &cc));
   tt_int_op(cell.command, ==, cell2.command);
-  test_memeq(cell.payload, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
 #else
   tt_int_op(-1, ==, create_cell_parse(&cc, &cell));
 #endif
@@ -470,10 +470,10 @@ test_cfmt_create_cells(void *arg)
   tt_int_op(CELL_CREATE, ==, cc.cell_type);
   tt_int_op(ONION_HANDSHAKE_TYPE_NTOR, ==, cc.handshake_type);
   tt_int_op(NTOR_ONIONSKIN_LEN, ==, cc.handshake_len);
-  test_memeq(cc.onionskin, b, NTOR_ONIONSKIN_LEN + 10);
+  tt_mem_op(cc.onionskin,==, b, NTOR_ONIONSKIN_LEN + 10);
   tt_int_op(0, ==, create_cell_format(&cell2, &cc));
   tt_int_op(cell.command, ==, cell2.command);
-  test_memeq(cell.payload, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
 #else
   tt_int_op(-1, ==, create_cell_parse(&cc, &cell));
 #endif
@@ -527,10 +527,10 @@ test_cfmt_created_cells(void *arg)
   tt_int_op(0, ==, created_cell_parse(&cc, &cell));
   tt_int_op(CELL_CREATED, ==, cc.cell_type);
   tt_int_op(TAP_ONIONSKIN_REPLY_LEN, ==, cc.handshake_len);
-  test_memeq(cc.reply, b, TAP_ONIONSKIN_REPLY_LEN + 10);
+  tt_mem_op(cc.reply,==, b, TAP_ONIONSKIN_REPLY_LEN + 10);
   tt_int_op(0, ==, created_cell_format(&cell2, &cc));
   tt_int_op(cell.command, ==, cell2.command);
-  test_memeq(cell.payload, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
 
   /* A good CREATED_FAST cell */
   memset(&cell, 0, sizeof(cell));
@@ -541,10 +541,10 @@ test_cfmt_created_cells(void *arg)
   tt_int_op(0, ==, created_cell_parse(&cc, &cell));
   tt_int_op(CELL_CREATED_FAST, ==, cc.cell_type);
   tt_int_op(CREATED_FAST_LEN, ==, cc.handshake_len);
-  test_memeq(cc.reply, b, CREATED_FAST_LEN + 10);
+  tt_mem_op(cc.reply,==, b, CREATED_FAST_LEN + 10);
   tt_int_op(0, ==, created_cell_format(&cell2, &cc));
   tt_int_op(cell.command, ==, cell2.command);
-  test_memeq(cell.payload, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
 
   /* A good CREATED2 cell with short reply */
   memset(&cell, 0, sizeof(cell));
@@ -556,10 +556,10 @@ test_cfmt_created_cells(void *arg)
   tt_int_op(0, ==, created_cell_parse(&cc, &cell));
   tt_int_op(CELL_CREATED2, ==, cc.cell_type);
   tt_int_op(64, ==, cc.handshake_len);
-  test_memeq(cc.reply, b, 80);
+  tt_mem_op(cc.reply,==, b, 80);
   tt_int_op(0, ==, created_cell_format(&cell2, &cc));
   tt_int_op(cell.command, ==, cell2.command);
-  test_memeq(cell.payload, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
 
   /* A good CREATED2 cell with maximal reply */
   memset(&cell, 0, sizeof(cell));
@@ -571,10 +571,10 @@ test_cfmt_created_cells(void *arg)
   tt_int_op(0, ==, created_cell_parse(&cc, &cell));
   tt_int_op(CELL_CREATED2, ==, cc.cell_type);
   tt_int_op(496, ==, cc.handshake_len);
-  test_memeq(cc.reply, b, 496);
+  tt_mem_op(cc.reply,==, b, 496);
   tt_int_op(0, ==, created_cell_format(&cell2, &cc));
   tt_int_op(cell.command, ==, cell2.command);
-  test_memeq(cell.payload, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
 
   /* Bogus CREATED2 cell: too long! */
   memset(&cell, 0, sizeof(cell));
@@ -620,15 +620,15 @@ test_cfmt_extend_cells(void *arg)
   tt_str_op("18.244.0.1", ==, fmt_addr(&ec.orport_ipv4.addr));
   tt_int_op(258, ==, ec.orport_ipv4.port);
   tt_int_op(AF_UNSPEC, ==, tor_addr_family(&ec.orport_ipv6.addr));
-  test_memeq(ec.node_id, "electroencephalogram", 20);
+  tt_mem_op(ec.node_id,==, "electroencephalogram", 20);
   tt_int_op(cc->cell_type, ==, CELL_CREATE);
   tt_int_op(cc->handshake_type, ==, ONION_HANDSHAKE_TYPE_TAP);
   tt_int_op(cc->handshake_len, ==, TAP_ONIONSKIN_CHALLENGE_LEN);
-  test_memeq(cc->onionskin, b, TAP_ONIONSKIN_CHALLENGE_LEN+20);
+  tt_mem_op(cc->onionskin,==, b, TAP_ONIONSKIN_CHALLENGE_LEN+20);
   tt_int_op(0, ==, extend_cell_format(&p2_cmd, &p2_len, p2, &ec));
   tt_int_op(p2_cmd, ==, RELAY_COMMAND_EXTEND);
   tt_int_op(p2_len, ==, 26+TAP_ONIONSKIN_CHALLENGE_LEN);
-  test_memeq(p2, p, RELAY_PAYLOAD_SIZE);
+  tt_mem_op(p2,==, p, RELAY_PAYLOAD_SIZE);
 
   /* Let's do an ntor stuffed in a legacy EXTEND cell */
   memset(p, 0, sizeof(p));
@@ -644,15 +644,15 @@ test_cfmt_extend_cells(void *arg)
   tt_str_op("18.244.0.1", ==, fmt_addr(&ec.orport_ipv4.addr));
   tt_int_op(258, ==, ec.orport_ipv4.port);
   tt_int_op(AF_UNSPEC, ==, tor_addr_family(&ec.orport_ipv6.addr));
-  test_memeq(ec.node_id, "electroencephalogram", 20);
+  tt_mem_op(ec.node_id,==, "electroencephalogram", 20);
   tt_int_op(cc->cell_type, ==, CELL_CREATE2);
   tt_int_op(cc->handshake_type, ==, ONION_HANDSHAKE_TYPE_NTOR);
   tt_int_op(cc->handshake_len, ==, NTOR_ONIONSKIN_LEN);
-  test_memeq(cc->onionskin, b, NTOR_ONIONSKIN_LEN+20);
+  tt_mem_op(cc->onionskin,==, b, NTOR_ONIONSKIN_LEN+20);
   tt_int_op(0, ==, extend_cell_format(&p2_cmd, &p2_len, p2, &ec));
   tt_int_op(p2_cmd, ==, RELAY_COMMAND_EXTEND);
   tt_int_op(p2_len, ==, 26+TAP_ONIONSKIN_CHALLENGE_LEN);
-  test_memeq(p2, p, RELAY_PAYLOAD_SIZE);
+  tt_mem_op(p2,==, p, RELAY_PAYLOAD_SIZE);
   tt_int_op(0, ==, create_cell_format_relayed(&cell, cc));
 
   /* Now let's do a minimal ntor EXTEND2 cell. */
@@ -673,15 +673,15 @@ test_cfmt_extend_cells(void *arg)
   tt_str_op("18.244.0.1", ==, fmt_addr(&ec.orport_ipv4.addr));
   tt_int_op(61681, ==, ec.orport_ipv4.port);
   tt_int_op(AF_UNSPEC, ==, tor_addr_family(&ec.orport_ipv6.addr));
-  test_memeq(ec.node_id, "anarchoindividualist", 20);
+  tt_mem_op(ec.node_id,==, "anarchoindividualist", 20);
   tt_int_op(cc->cell_type, ==, CELL_CREATE2);
   tt_int_op(cc->handshake_type, ==, ONION_HANDSHAKE_TYPE_NTOR);
   tt_int_op(cc->handshake_len, ==, NTOR_ONIONSKIN_LEN);
-  test_memeq(cc->onionskin, b, NTOR_ONIONSKIN_LEN+20);
+  tt_mem_op(cc->onionskin,==, b, NTOR_ONIONSKIN_LEN+20);
   tt_int_op(0, ==, extend_cell_format(&p2_cmd, &p2_len, p2, &ec));
   tt_int_op(p2_cmd, ==, RELAY_COMMAND_EXTEND2);
   tt_int_op(p2_len, ==, 35+NTOR_ONIONSKIN_LEN);
-  test_memeq(p2, p, RELAY_PAYLOAD_SIZE);
+  tt_mem_op(p2,==, p, RELAY_PAYLOAD_SIZE);
 
   /* Now let's do a fanciful EXTEND2 cell. */
   memset(&ec, 0xff, sizeof(ec));
@@ -706,11 +706,11 @@ test_cfmt_extend_cells(void *arg)
   tt_int_op(61681, ==, ec.orport_ipv4.port);
   tt_str_op("2002::f0:c51e", ==, fmt_addr(&ec.orport_ipv6.addr));
   tt_int_op(4370, ==, ec.orport_ipv6.port);
-  test_memeq(ec.node_id, "anthropomorphization", 20);
+  tt_mem_op(ec.node_id,==, "anthropomorphization", 20);
   tt_int_op(cc->cell_type, ==, CELL_CREATE2);
   tt_int_op(cc->handshake_type, ==, 0x105);
   tt_int_op(cc->handshake_len, ==, 99);
-  test_memeq(cc->onionskin, b, 99+20);
+  tt_mem_op(cc->onionskin,==, b, 99+20);
   tt_int_op(0, ==, extend_cell_format(&p2_cmd, &p2_len, p2, &ec));
   tt_int_op(p2_cmd, ==, RELAY_COMMAND_EXTEND2);
   /* We'll generate it minus the IPv6 address and minus the konami code */
@@ -722,7 +722,7 @@ test_cfmt_extend_cells(void *arg)
                  "0214616e7468726f706f6d6f727068697a6174696f6e"
                  /* Now the handshake prologue */
                  "01050063");
-  test_memeq(p2+1+8+22+4, b, 99+20);
+  tt_mem_op(p2+1+8+22+4,==, b, 99+20);
   tt_int_op(0, ==, create_cell_format_relayed(&cell, cc));
 
   /* == Now try parsing some junk */
@@ -836,11 +836,11 @@ test_cfmt_extended_cells(void *arg)
   tt_int_op(RELAY_COMMAND_EXTENDED, ==, ec.cell_type);
   tt_int_op(cc->cell_type, ==, CELL_CREATED);
   tt_int_op(cc->handshake_len, ==, TAP_ONIONSKIN_REPLY_LEN);
-  test_memeq(cc->reply, b, TAP_ONIONSKIN_REPLY_LEN);
+  tt_mem_op(cc->reply,==, b, TAP_ONIONSKIN_REPLY_LEN);
   tt_int_op(0, ==, extended_cell_format(&p2_cmd, &p2_len, p2, &ec));
   tt_int_op(RELAY_COMMAND_EXTENDED, ==, p2_cmd);
   tt_int_op(TAP_ONIONSKIN_REPLY_LEN, ==, p2_len);
-  test_memeq(p2, p, sizeof(p2));
+  tt_mem_op(p2,==, p, sizeof(p2));
 
   /* Try an EXTENDED2 cell */
   memset(&ec, 0xff, sizeof(ec));
@@ -853,11 +853,11 @@ test_cfmt_extended_cells(void *arg)
   tt_int_op(RELAY_COMMAND_EXTENDED2, ==, ec.cell_type);
   tt_int_op(cc->cell_type, ==, CELL_CREATED2);
   tt_int_op(cc->handshake_len, ==, 42);
-  test_memeq(cc->reply, b, 42+10);
+  tt_mem_op(cc->reply,==, b, 42+10);
   tt_int_op(0, ==, extended_cell_format(&p2_cmd, &p2_len, p2, &ec));
   tt_int_op(RELAY_COMMAND_EXTENDED2, ==, p2_cmd);
   tt_int_op(2+42, ==, p2_len);
-  test_memeq(p2, p, sizeof(p2));
+  tt_mem_op(p2,==, p, sizeof(p2));
 
   /* Try an almost-too-long EXTENDED2 cell */
   memcpy(p, "\x01\xf0", 2);
diff --git a/src/test/test_cell_queue.c b/src/test/test_cell_queue.c
index 92629823ec..3226f7b973 100644
--- a/src/test/test_cell_queue.c
+++ b/src/test/test_cell_queue.c
@@ -69,15 +69,15 @@ test_cq_manip(void *arg)
   pc_tmp = cell_queue_pop(&cq);
   tt_int_op(cq.n, ==, 1);
   tt_ptr_op(pc_tmp, !=, NULL);
-  test_mem_op(pc_tmp->body, ==, "\x12\x34\x56\x78\x0a", 5);
-  test_mem_op(pc_tmp->body+5, ==, cell.payload, sizeof(cell.payload));
+  tt_mem_op(pc_tmp->body, ==, "\x12\x34\x56\x78\x0a", 5);
+  tt_mem_op(pc_tmp->body+5, ==, cell.payload, sizeof(cell.payload));
   packed_cell_free(pc_tmp);
 
   pc_tmp = cell_queue_pop(&cq);
   tt_int_op(cq.n, ==, 0);
   tt_ptr_op(pc_tmp, !=, NULL);
-  test_mem_op(pc_tmp->body, ==, "\x20\x13\x0a", 3);
-  test_mem_op(pc_tmp->body+3, ==, cell.payload, sizeof(cell.payload));
+  tt_mem_op(pc_tmp->body, ==, "\x20\x13\x0a", 3);
+  tt_mem_op(pc_tmp->body+3, ==, cell.payload, sizeof(cell.payload));
   packed_cell_free(pc_tmp);
   pc_tmp = NULL;
 
diff --git a/src/test/test_circuitlist.c b/src/test/test_circuitlist.c
index 53dcab3302..e752eaf62a 100644
--- a/src/test/test_circuitlist.c
+++ b/src/test/test_circuitlist.c
@@ -251,7 +251,7 @@ test_rend_token_maps(void *arg)
 
   tt_ptr_op(c3->rendinfo, ==, NULL);
   tt_ptr_op(c4->rendinfo, !=, NULL);
-  test_mem_op(c4->rendinfo, ==, tok3, REND_TOKEN_LEN);
+  tt_mem_op(c4->rendinfo, ==, tok3, REND_TOKEN_LEN);
 
   /* Now clear c4's cookie. */
   circuit_set_intro_point_digest(c4, NULL);
diff --git a/src/test/test_circuitmux.c b/src/test/test_circuitmux.c
index b9c0436ebf..a3cacc4cc7 100644
--- a/src/test/test_circuitmux.c
+++ b/src/test/test_circuitmux.c
@@ -65,7 +65,7 @@ test_cmux_destroy_cell_queue(void *arg)
 
   pc = cell_queue_pop(cq);
   tt_assert(pc);
-  test_mem_op(pc->body, ==, "\x00\x00\x00\x64\x04\x0a\x00\x00\x00", 9);
+  tt_mem_op(pc->body, ==, "\x00\x00\x00\x64\x04\x0a\x00\x00\x00", 9);
   packed_cell_free(pc);
   pc = NULL;
 
diff --git a/src/test/test_config.c b/src/test/test_config.c
index b35984f761..6a91453e8c 100644
--- a/src/test/test_config.c
+++ b/src/test/test_config.c
@@ -53,57 +53,57 @@ test_config_addressmap(void *arg)
 
   /* MapAddress .invalidwildcard.com .torserver.exit  - no match */
   strlcpy(address, "www.invalidwildcard.com", sizeof(address));
-  test_assert(!addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_assert(!addressmap_rewrite(address, sizeof(address), &expires, NULL));
 
   /* MapAddress *invalidasterisk.com .torserver.exit  - no match */
   strlcpy(address, "www.invalidasterisk.com", sizeof(address));
-  test_assert(!addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_assert(!addressmap_rewrite(address, sizeof(address), &expires, NULL));
 
   /* Where no mapping for FQDN match on top-level domain */
   /* MapAddress .google.com .torserver.exit */
   strlcpy(address, "reader.google.com", sizeof(address));
-  test_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  test_streq(address, "reader.torserver.exit");
+  tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_str_op(address,==, "reader.torserver.exit");
 
   /* MapAddress *.yahoo.com *.google.com.torserver.exit */
   strlcpy(address, "reader.yahoo.com", sizeof(address));
-  test_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  test_streq(address, "reader.google.com.torserver.exit");
+  tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_str_op(address,==, "reader.google.com.torserver.exit");
 
   /*MapAddress *.cnn.com www.cnn.com */
   strlcpy(address, "cnn.com", sizeof(address));
-  test_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  test_streq(address, "www.cnn.com");
+  tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_str_op(address,==, "www.cnn.com");
 
   /* MapAddress .cn.com www.cnn.com */
   strlcpy(address, "www.cn.com", sizeof(address));
-  test_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  test_streq(address, "www.cnn.com");
+  tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_str_op(address,==, "www.cnn.com");
 
   /* MapAddress ex.com www.cnn.com  - no match */
   strlcpy(address, "www.ex.com", sizeof(address));
-  test_assert(!addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_assert(!addressmap_rewrite(address, sizeof(address), &expires, NULL));
 
   /* MapAddress ey.com *.cnn.com - invalid expression */
   strlcpy(address, "ey.com", sizeof(address));
-  test_assert(!addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_assert(!addressmap_rewrite(address, sizeof(address), &expires, NULL));
 
   /* Where mapping for FQDN match on FQDN */
   strlcpy(address, "www.google.com", sizeof(address));
-  test_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  test_streq(address, "3.3.3.3");
+  tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_str_op(address,==, "3.3.3.3");
 
   strlcpy(address, "www.torproject.org", sizeof(address));
-  test_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  test_streq(address, "1.1.1.1");
+  tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_str_op(address,==, "1.1.1.1");
 
   strlcpy(address, "other.torproject.org", sizeof(address));
-  test_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  test_streq(address, "this.torproject.org.otherserver.exit");
+  tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_str_op(address,==, "this.torproject.org.otherserver.exit");
 
   strlcpy(address, "test.torproject.org", sizeof(address));
-  test_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  test_streq(address, "2.2.2.2");
+  tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_str_op(address,==, "2.2.2.2");
 
   /* Test a chain of address mappings and the order in which they were added:
           "MapAddress www.example.org 4.4.4.4"
@@ -111,17 +111,17 @@ test_config_addressmap(void *arg)
           "MapAddress 4.4.4.4 5.5.5.5"
   */
   strlcpy(address, "www.example.org", sizeof(address));
-  test_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  test_streq(address, "5.5.5.5");
+  tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_str_op(address,==, "5.5.5.5");
 
   /* Test infinite address mapping results in no change */
   strlcpy(address, "www.infiniteloop.org", sizeof(address));
-  test_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  test_streq(address, "www.infiniteloop.org");
+  tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_str_op(address,==, "www.infiniteloop.org");
 
   /* Test we don't find false positives */
   strlcpy(address, "www.example.com", sizeof(address));
-  test_assert(!addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_assert(!addressmap_rewrite(address, sizeof(address), &expires, NULL));
 
   /* Test top-level-domain matching a bit harder */
   config_free_lines(get_options_mutable()->AddressMap);
@@ -134,24 +134,24 @@ test_config_addressmap(void *arg)
   config_register_addressmaps(get_options());
 
   strlcpy(address, "www.abc.com", sizeof(address));
-  test_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  test_streq(address, "www.abc.torserver.exit");
+  tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_str_op(address,==, "www.abc.torserver.exit");
 
   strlcpy(address, "www.def.com", sizeof(address));
-  test_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  test_streq(address, "www.def.torserver.exit");
+  tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_str_op(address,==, "www.def.torserver.exit");
 
   strlcpy(address, "www.torproject.org", sizeof(address));
-  test_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  test_streq(address, "1.1.1.1");
+  tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_str_op(address,==, "1.1.1.1");
 
   strlcpy(address, "test.torproject.org", sizeof(address));
-  test_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  test_streq(address, "1.1.1.1");
+  tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_str_op(address,==, "1.1.1.1");
 
   strlcpy(address, "torproject.net", sizeof(address));
-  test_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  test_streq(address, "2.2.2.2");
+  tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_str_op(address,==, "2.2.2.2");
 
   /* We don't support '*' as a mapping directive */
   config_free_lines(get_options_mutable()->AddressMap);
@@ -161,13 +161,13 @@ test_config_addressmap(void *arg)
   config_register_addressmaps(get_options());
 
   strlcpy(address, "www.abc.com", sizeof(address));
-  test_assert(!addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_assert(!addressmap_rewrite(address, sizeof(address), &expires, NULL));
 
   strlcpy(address, "www.def.net", sizeof(address));
-  test_assert(!addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_assert(!addressmap_rewrite(address, sizeof(address), &expires, NULL));
 
   strlcpy(address, "www.torproject.org", sizeof(address));
-  test_assert(!addressmap_rewrite(address, sizeof(address), &expires, NULL));
+  tt_assert(!addressmap_rewrite(address, sizeof(address), &expires, NULL));
 
 #undef addressmap_rewrite
 
@@ -220,13 +220,13 @@ test_config_check_or_create_data_subdir(void *arg)
 
   // The subdirectory shouldn't exist yet,
   // but should be created by the call to check_or_create_data_subdir.
-  test_assert(r && (errno == ENOENT));
-  test_assert(!check_or_create_data_subdir(subdir));
-  test_assert(is_private_dir(subpath));
+  tt_assert(r && (errno == ENOENT));
+  tt_assert(!check_or_create_data_subdir(subdir));
+  tt_assert(is_private_dir(subpath));
 
   // The check should return 0, if the directory already exists
   // and is private to the user.
-  test_assert(!check_or_create_data_subdir(subdir));
+  tt_assert(!check_or_create_data_subdir(subdir));
 
   r = stat(subpath, &st);
   if (r) {
@@ -243,9 +243,9 @@ test_config_check_or_create_data_subdir(void *arg)
 
   // If the directory exists, but its mode is too permissive
   // a call to check_or_create_data_subdir should reset the mode.
-  test_assert(!is_private_dir(subpath));
-  test_assert(!check_or_create_data_subdir(subdir));
-  test_assert(is_private_dir(subpath));
+  tt_assert(!is_private_dir(subpath));
+  tt_assert(!check_or_create_data_subdir(subdir));
+  tt_assert(is_private_dir(subpath));
 #endif
 
  done:
@@ -291,20 +291,20 @@ test_config_write_to_data_subdir(void *arg)
 #endif
 
   // Write attempt shoudl fail, if subdirectory doesn't exist.
-  test_assert(write_to_data_subdir(subdir, fname, str, NULL));
-  test_assert(! check_or_create_data_subdir(subdir));
+  tt_assert(write_to_data_subdir(subdir, fname, str, NULL));
+  tt_assert(! check_or_create_data_subdir(subdir));
 
   // Content of file after write attempt should be
   // equal to the original string.
-  test_assert(!write_to_data_subdir(subdir, fname, str, NULL));
+  tt_assert(!write_to_data_subdir(subdir, fname, str, NULL));
   cp = read_file_to_str(filepath, 0, NULL);
-  test_streq(cp, str);
+  tt_str_op(cp,==, str);
   tor_free(cp);
 
   // A second write operation should overwrite the old content.
-  test_assert(!write_to_data_subdir(subdir, fname, str, NULL));
+  tt_assert(!write_to_data_subdir(subdir, fname, str, NULL));
   cp = read_file_to_str(filepath, 0, NULL);
-  test_streq(cp, str);
+  tt_str_op(cp,==, str);
   tor_free(cp);
 
  done:
@@ -325,48 +325,48 @@ good_bridge_line_test(const char *string, const char *test_addrport,
 {
   char *tmp = NULL;
   bridge_line_t *bridge_line = parse_bridge_line(string);
-  test_assert(bridge_line);
+  tt_assert(bridge_line);
 
   /* test addrport */
   tmp = tor_strdup(fmt_addrport(&bridge_line->addr, bridge_line->port));
-  test_streq(test_addrport, tmp);
+  tt_str_op(test_addrport,==, tmp);
   tor_free(tmp);
 
   /* If we were asked to validate a digest, but we did not get a
      digest after parsing, we failed. */
   if (test_digest && tor_digest_is_zero(bridge_line->digest))
-    test_assert(0);
+    tt_assert(0);
 
   /* If we were not asked to validate a digest, and we got a digest
      after parsing, we failed again. */
   if (!test_digest && !tor_digest_is_zero(bridge_line->digest))
-    test_assert(0);
+    tt_assert(0);
 
   /* If we were asked to validate a digest, and we got a digest after
      parsing, make sure it's correct. */
   if (test_digest) {
     tmp = tor_strdup(hex_str(bridge_line->digest, DIGEST_LEN));
     tor_strlower(tmp);
-    test_streq(test_digest, tmp);
+    tt_str_op(test_digest,==, tmp);
     tor_free(tmp);
   }
 
   /* If we were asked to validate a transport name, make sure tha it
      matches with the transport name that was parsed. */
   if (test_transport && !bridge_line->transport_name)
-    test_assert(0);
+    tt_assert(0);
   if (!test_transport && bridge_line->transport_name)
-    test_assert(0);
+    tt_assert(0);
   if (test_transport)
-    test_streq(test_transport, bridge_line->transport_name);
+    tt_str_op(test_transport,==, bridge_line->transport_name);
 
   /* Validate the SOCKS argument smartlist. */
   if (test_socks_args && !bridge_line->socks_args)
-    test_assert(0);
+    tt_assert(0);
   if (!test_socks_args && bridge_line->socks_args)
-    test_assert(0);
+    tt_assert(0);
   if (test_socks_args)
-    test_assert(smartlist_strings_eq(test_socks_args,
+    tt_assert(smartlist_strings_eq(test_socks_args,
                                      bridge_line->socks_args));
 
  done:
@@ -382,7 +382,7 @@ bad_bridge_line_test(const char *string)
   bridge_line_t *bridge_line = parse_bridge_line(string);
   if (bridge_line)
     TT_FAIL(("%s was supposed to fail, but it didn't.", string));
-  test_assert(!bridge_line);
+  tt_assert(!bridge_line);
 
  done:
   bridge_line_free(bridge_line);
@@ -490,18 +490,18 @@ test_config_parse_transport_options_line(void *arg)
 
   { /* too small line */
     options_sl = get_options_from_transport_options_line("valley", NULL);
-    test_assert(!options_sl);
+    tt_assert(!options_sl);
   }
 
   { /* no k=v values */
     options_sl = get_options_from_transport_options_line("hit it!", NULL);
-    test_assert(!options_sl);
+    tt_assert(!options_sl);
   }
 
   { /* correct line, but wrong transport specified */
     options_sl =
       get_options_from_transport_options_line("trebuchet k=v", "rook");
-    test_assert(!options_sl);
+    tt_assert(!options_sl);
   }
 
   { /* correct -- no transport specified */
@@ -512,8 +512,8 @@ test_config_parse_transport_options_line(void *arg)
     options_sl =
       get_options_from_transport_options_line("rook ladi=dadi weliketo=party",
                                               NULL);
-    test_assert(options_sl);
-    test_assert(smartlist_strings_eq(options_sl, sl_tmp));
+    tt_assert(options_sl);
+    tt_assert(smartlist_strings_eq(options_sl, sl_tmp));
 
     SMARTLIST_FOREACH(sl_tmp, char *, s, tor_free(s));
     smartlist_free(sl_tmp);
@@ -531,8 +531,8 @@ test_config_parse_transport_options_line(void *arg)
     options_sl =
       get_options_from_transport_options_line("rook ladi=dadi weliketo=party",
                                               "rook");
-    test_assert(options_sl);
-    test_assert(smartlist_strings_eq(options_sl, sl_tmp));
+    tt_assert(options_sl);
+    tt_assert(smartlist_strings_eq(options_sl, sl_tmp));
     SMARTLIST_FOREACH(sl_tmp, char *, s, tor_free(s));
     smartlist_free(sl_tmp);
     sl_tmp = NULL;
@@ -576,7 +576,7 @@ test_config_fix_my_family(void *arg)
     TT_FAIL(("options_validate failed: %s", err));
   }
 
-  test_streq(options->MyFamily, "$1111111111111111111111111111111111111111, "
+  tt_str_op(options->MyFamily,==, "$1111111111111111111111111111111111111111, "
                                 "$1111111111111111111111111111111111111112, "
                                 "$1111111111111111111111111111111111111113");
 
diff --git a/src/test/test_containers.c b/src/test/test_containers.c
index d7b7b3cfee..506d2130ca 100644
--- a/src/test/test_containers.c
+++ b/src/test/test_containers.c
@@ -61,22 +61,22 @@ test_container_smartlist_basic(void)
   smartlist_insert(sl, 1, v22);
   smartlist_insert(sl, 0, v0);
   smartlist_insert(sl, 5, v555);
-  test_eq_ptr(v0,   smartlist_get(sl,0));
-  test_eq_ptr(v1,   smartlist_get(sl,1));
-  test_eq_ptr(v22,  smartlist_get(sl,2));
-  test_eq_ptr(v3,   smartlist_get(sl,3));
-  test_eq_ptr(v4,   smartlist_get(sl,4));
-  test_eq_ptr(v555, smartlist_get(sl,5));
+  tt_ptr_op(v0,==,   smartlist_get(sl,0));
+  tt_ptr_op(v1,==,   smartlist_get(sl,1));
+  tt_ptr_op(v22,==,  smartlist_get(sl,2));
+  tt_ptr_op(v3,==,   smartlist_get(sl,3));
+  tt_ptr_op(v4,==,   smartlist_get(sl,4));
+  tt_ptr_op(v555,==, smartlist_get(sl,5));
   /* Try deleting in the middle. */
   smartlist_del(sl, 1);
-  test_eq_ptr(v555, smartlist_get(sl, 1));
+  tt_ptr_op(v555,==, smartlist_get(sl, 1));
   /* Try deleting at the end. */
   smartlist_del(sl, 4);
-  test_eq(4, smartlist_len(sl));
+  tt_int_op(4,==, smartlist_len(sl));
 
   /* test isin. */
-  test_assert(smartlist_contains(sl, v3));
-  test_assert(!smartlist_contains(sl, v99));
+  tt_assert(smartlist_contains(sl, v3));
+  tt_assert(!smartlist_contains(sl, v99));
 
  done:
   smartlist_free(sl);
@@ -99,191 +99,191 @@ test_container_smartlist_strings(void)
   size_t sz;
 
   /* Test split and join */
-  test_eq(0, smartlist_len(sl));
+  tt_int_op(0,==, smartlist_len(sl));
   smartlist_split_string(sl, "abc", ":", 0, 0);
-  test_eq(1, smartlist_len(sl));
-  test_streq("abc", smartlist_get(sl, 0));
+  tt_int_op(1,==, smartlist_len(sl));
+  tt_str_op("abc",==, smartlist_get(sl, 0));
   smartlist_split_string(sl, "a::bc::", "::", 0, 0);
-  test_eq(4, smartlist_len(sl));
-  test_streq("a", smartlist_get(sl, 1));
-  test_streq("bc", smartlist_get(sl, 2));
-  test_streq("", smartlist_get(sl, 3));
+  tt_int_op(4,==, smartlist_len(sl));
+  tt_str_op("a",==, smartlist_get(sl, 1));
+  tt_str_op("bc",==, smartlist_get(sl, 2));
+  tt_str_op("",==, smartlist_get(sl, 3));
   cp_alloc = smartlist_join_strings(sl, "", 0, NULL);
-  test_streq(cp_alloc, "abcabc");
+  tt_str_op(cp_alloc,==, "abcabc");
   tor_free(cp_alloc);
   cp_alloc = smartlist_join_strings(sl, "!", 0, NULL);
-  test_streq(cp_alloc, "abc!a!bc!");
+  tt_str_op(cp_alloc,==, "abc!a!bc!");
   tor_free(cp_alloc);
   cp_alloc = smartlist_join_strings(sl, "XY", 0, NULL);
-  test_streq(cp_alloc, "abcXYaXYbcXY");
+  tt_str_op(cp_alloc,==, "abcXYaXYbcXY");
   tor_free(cp_alloc);
   cp_alloc = smartlist_join_strings(sl, "XY", 1, NULL);
-  test_streq(cp_alloc, "abcXYaXYbcXYXY");
+  tt_str_op(cp_alloc,==, "abcXYaXYbcXYXY");
   tor_free(cp_alloc);
   cp_alloc = smartlist_join_strings(sl, "", 1, NULL);
-  test_streq(cp_alloc, "abcabc");
+  tt_str_op(cp_alloc,==, "abcabc");
   tor_free(cp_alloc);
 
   smartlist_split_string(sl, "/def/  /ghijk", "/", 0, 0);
-  test_eq(8, smartlist_len(sl));
-  test_streq("", smartlist_get(sl, 4));
-  test_streq("def", smartlist_get(sl, 5));
-  test_streq("  ", smartlist_get(sl, 6));
-  test_streq("ghijk", smartlist_get(sl, 7));
+  tt_int_op(8,==, smartlist_len(sl));
+  tt_str_op("",==, smartlist_get(sl, 4));
+  tt_str_op("def",==, smartlist_get(sl, 5));
+  tt_str_op("  ",==, smartlist_get(sl, 6));
+  tt_str_op("ghijk",==, smartlist_get(sl, 7));
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
 
   smartlist_split_string(sl, "a,bbd,cdef", ",", SPLIT_SKIP_SPACE, 0);
-  test_eq(3, smartlist_len(sl));
-  test_streq("a", smartlist_get(sl,0));
-  test_streq("bbd", smartlist_get(sl,1));
-  test_streq("cdef", smartlist_get(sl,2));
+  tt_int_op(3,==, smartlist_len(sl));
+  tt_str_op("a",==, smartlist_get(sl,0));
+  tt_str_op("bbd",==, smartlist_get(sl,1));
+  tt_str_op("cdef",==, smartlist_get(sl,2));
   smartlist_split_string(sl, " z <> zhasd <>  <> bnud<>   ", "<>",
                          SPLIT_SKIP_SPACE, 0);
-  test_eq(8, smartlist_len(sl));
-  test_streq("z", smartlist_get(sl,3));
-  test_streq("zhasd", smartlist_get(sl,4));
-  test_streq("", smartlist_get(sl,5));
-  test_streq("bnud", smartlist_get(sl,6));
-  test_streq("", smartlist_get(sl,7));
+  tt_int_op(8,==, smartlist_len(sl));
+  tt_str_op("z",==, smartlist_get(sl,3));
+  tt_str_op("zhasd",==, smartlist_get(sl,4));
+  tt_str_op("",==, smartlist_get(sl,5));
+  tt_str_op("bnud",==, smartlist_get(sl,6));
+  tt_str_op("",==, smartlist_get(sl,7));
 
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
 
   smartlist_split_string(sl, " ab\tc \td ef  ", NULL,
                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
-  test_eq(4, smartlist_len(sl));
-  test_streq("ab", smartlist_get(sl,0));
-  test_streq("c", smartlist_get(sl,1));
-  test_streq("d", smartlist_get(sl,2));
-  test_streq("ef", smartlist_get(sl,3));
+  tt_int_op(4,==, smartlist_len(sl));
+  tt_str_op("ab",==, smartlist_get(sl,0));
+  tt_str_op("c",==, smartlist_get(sl,1));
+  tt_str_op("d",==, smartlist_get(sl,2));
+  tt_str_op("ef",==, smartlist_get(sl,3));
   smartlist_split_string(sl, "ghi\tj", NULL,
                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
-  test_eq(6, smartlist_len(sl));
-  test_streq("ghi", smartlist_get(sl,4));
-  test_streq("j", smartlist_get(sl,5));
+  tt_int_op(6,==, smartlist_len(sl));
+  tt_str_op("ghi",==, smartlist_get(sl,4));
+  tt_str_op("j",==, smartlist_get(sl,5));
 
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
 
   cp_alloc = smartlist_join_strings(sl, "XY", 0, NULL);
-  test_streq(cp_alloc, "");
+  tt_str_op(cp_alloc,==, "");
   tor_free(cp_alloc);
   cp_alloc = smartlist_join_strings(sl, "XY", 1, NULL);
-  test_streq(cp_alloc, "XY");
+  tt_str_op(cp_alloc,==, "XY");
   tor_free(cp_alloc);
 
   smartlist_split_string(sl, " z <> zhasd <>  <> bnud<>   ", "<>",
                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
-  test_eq(3, smartlist_len(sl));
-  test_streq("z", smartlist_get(sl, 0));
-  test_streq("zhasd", smartlist_get(sl, 1));
-  test_streq("bnud", smartlist_get(sl, 2));
+  tt_int_op(3,==, smartlist_len(sl));
+  tt_str_op("z",==, smartlist_get(sl, 0));
+  tt_str_op("zhasd",==, smartlist_get(sl, 1));
+  tt_str_op("bnud",==, smartlist_get(sl, 2));
   smartlist_split_string(sl, " z <> zhasd <>  <> bnud<>   ", "<>",
                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 2);
-  test_eq(5, smartlist_len(sl));
-  test_streq("z", smartlist_get(sl, 3));
-  test_streq("zhasd <>  <> bnud<>", smartlist_get(sl, 4));
+  tt_int_op(5,==, smartlist_len(sl));
+  tt_str_op("z",==, smartlist_get(sl, 3));
+  tt_str_op("zhasd <>  <> bnud<>",==, smartlist_get(sl, 4));
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
 
   smartlist_split_string(sl, "abcd\n", "\n",
                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
-  test_eq(1, smartlist_len(sl));
-  test_streq("abcd", smartlist_get(sl, 0));
+  tt_int_op(1,==, smartlist_len(sl));
+  tt_str_op("abcd",==, smartlist_get(sl, 0));
   smartlist_split_string(sl, "efgh", "\n",
                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
-  test_eq(2, smartlist_len(sl));
-  test_streq("efgh", smartlist_get(sl, 1));
+  tt_int_op(2,==, smartlist_len(sl));
+  tt_str_op("efgh",==, smartlist_get(sl, 1));
 
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
 
   /* Test swapping, shuffling, and sorting. */
   smartlist_split_string(sl, "the,onion,router,by,arma,and,nickm", ",", 0, 0);
-  test_eq(7, smartlist_len(sl));
+  tt_int_op(7,==, smartlist_len(sl));
   smartlist_sort(sl, compare_strs_);
   cp_alloc = smartlist_join_strings(sl, ",", 0, NULL);
-  test_streq(cp_alloc,"and,arma,by,nickm,onion,router,the");
+  tt_str_op(cp_alloc,==, "and,arma,by,nickm,onion,router,the");
   tor_free(cp_alloc);
   smartlist_swap(sl, 1, 5);
   cp_alloc = smartlist_join_strings(sl, ",", 0, NULL);
-  test_streq(cp_alloc,"and,router,by,nickm,onion,arma,the");
+  tt_str_op(cp_alloc,==, "and,router,by,nickm,onion,arma,the");
   tor_free(cp_alloc);
   smartlist_shuffle(sl);
-  test_eq(7, smartlist_len(sl));
-  test_assert(smartlist_contains_string(sl, "and"));
-  test_assert(smartlist_contains_string(sl, "router"));
-  test_assert(smartlist_contains_string(sl, "by"));
-  test_assert(smartlist_contains_string(sl, "nickm"));
-  test_assert(smartlist_contains_string(sl, "onion"));
-  test_assert(smartlist_contains_string(sl, "arma"));
-  test_assert(smartlist_contains_string(sl, "the"));
+  tt_int_op(7,==, smartlist_len(sl));
+  tt_assert(smartlist_contains_string(sl, "and"));
+  tt_assert(smartlist_contains_string(sl, "router"));
+  tt_assert(smartlist_contains_string(sl, "by"));
+  tt_assert(smartlist_contains_string(sl, "nickm"));
+  tt_assert(smartlist_contains_string(sl, "onion"));
+  tt_assert(smartlist_contains_string(sl, "arma"));
+  tt_assert(smartlist_contains_string(sl, "the"));
 
   /* Test bsearch. */
   smartlist_sort(sl, compare_strs_);
-  test_streq("nickm", smartlist_bsearch(sl, "zNicKM",
+  tt_str_op("nickm",==, smartlist_bsearch(sl, "zNicKM",
                                         compare_without_first_ch_));
-  test_streq("and", smartlist_bsearch(sl, " AND", compare_without_first_ch_));
-  test_eq_ptr(NULL, smartlist_bsearch(sl, " ANz", compare_without_first_ch_));
+  tt_str_op("and",==, smartlist_bsearch(sl, " AND", compare_without_first_ch_));
+  tt_ptr_op(NULL,==, smartlist_bsearch(sl, " ANz", compare_without_first_ch_));
 
   /* Test bsearch_idx */
   {
     int f;
     smartlist_t *tmp = NULL;
 
-    test_eq(0, smartlist_bsearch_idx(sl," aaa",compare_without_first_ch_,&f));
-    test_eq(f, 0);
-    test_eq(0, smartlist_bsearch_idx(sl," and",compare_without_first_ch_,&f));
-    test_eq(f, 1);
-    test_eq(1, smartlist_bsearch_idx(sl," arm",compare_without_first_ch_,&f));
-    test_eq(f, 0);
-    test_eq(1, smartlist_bsearch_idx(sl," arma",compare_without_first_ch_,&f));
-    test_eq(f, 1);
-    test_eq(2, smartlist_bsearch_idx(sl," armb",compare_without_first_ch_,&f));
-    test_eq(f, 0);
-    test_eq(7, smartlist_bsearch_idx(sl," zzzz",compare_without_first_ch_,&f));
-    test_eq(f, 0);
+    tt_int_op(0,==, smartlist_bsearch_idx(sl," aaa",compare_without_first_ch_,&f));
+    tt_int_op(f,==, 0);
+    tt_int_op(0,==, smartlist_bsearch_idx(sl," and",compare_without_first_ch_,&f));
+    tt_int_op(f,==, 1);
+    tt_int_op(1,==, smartlist_bsearch_idx(sl," arm",compare_without_first_ch_,&f));
+    tt_int_op(f,==, 0);
+    tt_int_op(1,==, smartlist_bsearch_idx(sl," arma",compare_without_first_ch_,&f));
+    tt_int_op(f,==, 1);
+    tt_int_op(2,==, smartlist_bsearch_idx(sl," armb",compare_without_first_ch_,&f));
+    tt_int_op(f,==, 0);
+    tt_int_op(7,==, smartlist_bsearch_idx(sl," zzzz",compare_without_first_ch_,&f));
+    tt_int_op(f,==, 0);
 
     /* Test trivial cases for list of length 0 or 1 */
     tmp = smartlist_new();
-    test_eq(0, smartlist_bsearch_idx(tmp, "foo",
+    tt_int_op(0,==, smartlist_bsearch_idx(tmp, "foo",
                                      compare_strs_for_bsearch_, &f));
-    test_eq(f, 0);
+    tt_int_op(f,==, 0);
     smartlist_insert(tmp, 0, (void *)("bar"));
-    test_eq(1, smartlist_bsearch_idx(tmp, "foo",
+    tt_int_op(1,==, smartlist_bsearch_idx(tmp, "foo",
                                      compare_strs_for_bsearch_, &f));
-    test_eq(f, 0);
-    test_eq(0, smartlist_bsearch_idx(tmp, "aaa",
+    tt_int_op(f,==, 0);
+    tt_int_op(0,==, smartlist_bsearch_idx(tmp, "aaa",
                                      compare_strs_for_bsearch_, &f));
-    test_eq(f, 0);
-    test_eq(0, smartlist_bsearch_idx(tmp, "bar",
+    tt_int_op(f,==, 0);
+    tt_int_op(0,==, smartlist_bsearch_idx(tmp, "bar",
                                      compare_strs_for_bsearch_, &f));
-    test_eq(f, 1);
+    tt_int_op(f,==, 1);
     /* ... and one for length 2 */
     smartlist_insert(tmp, 1, (void *)("foo"));
-    test_eq(1, smartlist_bsearch_idx(tmp, "foo",
+    tt_int_op(1,==, smartlist_bsearch_idx(tmp, "foo",
                                      compare_strs_for_bsearch_, &f));
-    test_eq(f, 1);
-    test_eq(2, smartlist_bsearch_idx(tmp, "goo",
+    tt_int_op(f,==, 1);
+    tt_int_op(2,==, smartlist_bsearch_idx(tmp, "goo",
                                      compare_strs_for_bsearch_, &f));
-    test_eq(f, 0);
+    tt_int_op(f,==, 0);
     smartlist_free(tmp);
   }
 
   /* Test reverse() and pop_last() */
   smartlist_reverse(sl);
   cp_alloc = smartlist_join_strings(sl, ",", 0, NULL);
-  test_streq(cp_alloc,"the,router,onion,nickm,by,arma,and");
+  tt_str_op(cp_alloc,==, "the,router,onion,nickm,by,arma,and");
   tor_free(cp_alloc);
   cp_alloc = smartlist_pop_last(sl);
-  test_streq(cp_alloc, "and");
+  tt_str_op(cp_alloc,==, "and");
   tor_free(cp_alloc);
-  test_eq(smartlist_len(sl), 6);
+  tt_int_op(smartlist_len(sl),==, 6);
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
   cp_alloc = smartlist_pop_last(sl);
-  test_eq_ptr(cp_alloc, NULL);
+  tt_ptr_op(cp_alloc,==, NULL);
 
   /* Test uniq() */
   smartlist_split_string(sl,
@@ -292,16 +292,16 @@ test_container_smartlist_strings(void)
   smartlist_sort(sl, compare_strs_);
   smartlist_uniq(sl, compare_strs_, tor_free_);
   cp_alloc = smartlist_join_strings(sl, ",", 0, NULL);
-  test_streq(cp_alloc, "50,a,canal,man,noon,panama,plan,radar");
+  tt_str_op(cp_alloc,==, "50,a,canal,man,noon,panama,plan,radar");
   tor_free(cp_alloc);
 
   /* Test contains_string, contains_string_case and contains_int_as_string */
-  test_assert(smartlist_contains_string(sl, "noon"));
-  test_assert(!smartlist_contains_string(sl, "noonoon"));
-  test_assert(smartlist_contains_string_case(sl, "nOOn"));
-  test_assert(!smartlist_contains_string_case(sl, "nooNooN"));
-  test_assert(smartlist_contains_int_as_string(sl, 50));
-  test_assert(!smartlist_contains_int_as_string(sl, 60));
+  tt_assert(smartlist_contains_string(sl, "noon"));
+  tt_assert(!smartlist_contains_string(sl, "noonoon"));
+  tt_assert(smartlist_contains_string_case(sl, "nOOn"));
+  tt_assert(!smartlist_contains_string_case(sl, "nooNooN"));
+  tt_assert(smartlist_contains_int_as_string(sl, 50));
+  tt_assert(!smartlist_contains_int_as_string(sl, 60));
 
   /* Test smartlist_choose */
   {
@@ -309,7 +309,7 @@ test_container_smartlist_strings(void)
     int allsame = 1;
     int allin = 1;
     void *first = smartlist_choose(sl);
-    test_assert(smartlist_contains(sl, first));
+    tt_assert(smartlist_contains(sl, first));
     for (i = 0; i < 100; ++i) {
       void *second = smartlist_choose(sl);
       if (second != first)
@@ -317,8 +317,8 @@ test_container_smartlist_strings(void)
       if (!smartlist_contains(sl, second))
         allin = 0;
     }
-    test_assert(!allsame);
-    test_assert(allin);
+    tt_assert(!allsame);
+    tt_assert(allin);
   }
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
@@ -328,17 +328,17 @@ test_container_smartlist_strings(void)
                     "Some say the Earth will end in ice and some in fire",
                     " ", 0, 0);
   cp = smartlist_get(sl, 4);
-  test_streq(cp, "will");
+  tt_str_op(cp,==, "will");
   smartlist_add(sl, cp);
   smartlist_remove(sl, cp);
   tor_free(cp);
   cp_alloc = smartlist_join_strings(sl, ",", 0, NULL);
-  test_streq(cp_alloc, "Some,say,the,Earth,fire,end,in,ice,and,some,in");
+  tt_str_op(cp_alloc,==, "Some,say,the,Earth,fire,end,in,ice,and,some,in");
   tor_free(cp_alloc);
   smartlist_string_remove(sl, "in");
   cp_alloc = smartlist_join_strings2(sl, "+XX", 1, 0, &sz);
-  test_streq(cp_alloc, "Some+say+the+Earth+fire+end+some+ice+and");
-  test_eq((int)sz, 40);
+  tt_str_op(cp_alloc,==, "Some+say+the+Earth+fire+end+some+ice+and");
+  tt_int_op((int)sz,==, 40);
 
  done:
 
@@ -365,7 +365,7 @@ test_container_smartlist_overlap(void)
   /* add_all */
   smartlist_add_all(ints, odds);
   smartlist_add_all(ints, evens);
-  test_eq(smartlist_len(ints), 10);
+  tt_int_op(smartlist_len(ints),==, 10);
 
   smartlist_add(primes, (void*)2);
   smartlist_add(primes, (void*)3);
@@ -373,24 +373,24 @@ test_container_smartlist_overlap(void)
   smartlist_add(primes, (void*)7);
 
   /* overlap */
-  test_assert(smartlist_overlap(ints, odds));
-  test_assert(smartlist_overlap(odds, primes));
-  test_assert(smartlist_overlap(evens, primes));
-  test_assert(!smartlist_overlap(odds, evens));
+  tt_assert(smartlist_overlap(ints, odds));
+  tt_assert(smartlist_overlap(odds, primes));
+  tt_assert(smartlist_overlap(evens, primes));
+  tt_assert(!smartlist_overlap(odds, evens));
 
   /* intersect */
   smartlist_add_all(sl, odds);
   smartlist_intersect(sl, primes);
-  test_eq(smartlist_len(sl), 3);
-  test_assert(smartlist_contains(sl, (void*)3));
-  test_assert(smartlist_contains(sl, (void*)5));
-  test_assert(smartlist_contains(sl, (void*)7));
+  tt_int_op(smartlist_len(sl),==, 3);
+  tt_assert(smartlist_contains(sl, (void*)3));
+  tt_assert(smartlist_contains(sl, (void*)5));
+  tt_assert(smartlist_contains(sl, (void*)7));
 
   /* subtract */
   smartlist_add_all(sl, primes);
   smartlist_subtract(sl, odds);
-  test_eq(smartlist_len(sl), 1);
-  test_assert(smartlist_contains(sl, (void*)2));
+  tt_int_op(smartlist_len(sl),==, 1);
+  tt_assert(smartlist_contains(sl, (void*)2));
 
  done:
   smartlist_free(odds);
@@ -410,23 +410,23 @@ test_container_smartlist_digests(void)
   smartlist_add(sl, tor_memdup("AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN));
   smartlist_add(sl, tor_memdup("\00090AAB2AAAAaasdAAAAA", DIGEST_LEN));
   smartlist_add(sl, tor_memdup("\00090AAB2AAAAaasdAAAAA", DIGEST_LEN));
-  test_eq(0, smartlist_contains_digest(NULL, "AAAAAAAAAAAAAAAAAAAA"));
-  test_assert(smartlist_contains_digest(sl, "AAAAAAAAAAAAAAAAAAAA"));
-  test_assert(smartlist_contains_digest(sl, "\00090AAB2AAAAaasdAAAAA"));
-  test_eq(0, smartlist_contains_digest(sl, "\00090AAB2AAABaasdAAAAA"));
+  tt_int_op(0,==, smartlist_contains_digest(NULL, "AAAAAAAAAAAAAAAAAAAA"));
+  tt_assert(smartlist_contains_digest(sl, "AAAAAAAAAAAAAAAAAAAA"));
+  tt_assert(smartlist_contains_digest(sl, "\00090AAB2AAAAaasdAAAAA"));
+  tt_int_op(0,==, smartlist_contains_digest(sl, "\00090AAB2AAABaasdAAAAA"));
 
   /* sort digests */
   smartlist_sort_digests(sl);
-  test_memeq(smartlist_get(sl, 0), "\00090AAB2AAAAaasdAAAAA", DIGEST_LEN);
-  test_memeq(smartlist_get(sl, 1), "\00090AAB2AAAAaasdAAAAA", DIGEST_LEN);
-  test_memeq(smartlist_get(sl, 2), "AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN);
-  test_eq(3, smartlist_len(sl));
+  tt_mem_op(smartlist_get(sl, 0),==, "\00090AAB2AAAAaasdAAAAA", DIGEST_LEN);
+  tt_mem_op(smartlist_get(sl, 1),==, "\00090AAB2AAAAaasdAAAAA", DIGEST_LEN);
+  tt_mem_op(smartlist_get(sl, 2),==, "AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN);
+  tt_int_op(3,==, smartlist_len(sl));
 
   /* uniq_digests */
   smartlist_uniq_digests(sl);
-  test_eq(2, smartlist_len(sl));
-  test_memeq(smartlist_get(sl, 0), "\00090AAB2AAAAaasdAAAAA", DIGEST_LEN);
-  test_memeq(smartlist_get(sl, 1), "AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN);
+  tt_int_op(2,==, smartlist_len(sl));
+  tt_mem_op(smartlist_get(sl, 0),==, "\00090AAB2AAAAaasdAAAAA", DIGEST_LEN);
+  tt_mem_op(smartlist_get(sl, 1),==, "AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN);
 
  done:
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
@@ -457,21 +457,21 @@ test_container_smartlist_join(void)
                          sl2, char *, cp2,
                          strcmp(cp1,cp2),
                          smartlist_add(sl3, cp2)) {
-    test_streq(cp1, cp2);
+    tt_str_op(cp1,==, cp2);
     smartlist_add(sl4, cp1);
   } SMARTLIST_FOREACH_JOIN_END(cp1, cp2);
 
   SMARTLIST_FOREACH(sl3, const char *, cp,
-                    test_assert(smartlist_contains(sl2, cp) &&
+                    tt_assert(smartlist_contains(sl2, cp) &&
                                 !smartlist_contains_string(sl, cp)));
   SMARTLIST_FOREACH(sl4, const char *, cp,
-                    test_assert(smartlist_contains(sl, cp) &&
+                    tt_assert(smartlist_contains(sl, cp) &&
                                 smartlist_contains_string(sl2, cp)));
   joined = smartlist_join_strings(sl3, ",", 0, NULL);
-  test_streq(joined, "Anemias,Anemias,Crossbowmen,Work");
+  tt_str_op(joined,==, "Anemias,Anemias,Crossbowmen,Work");
   tor_free(joined);
   joined = smartlist_join_strings(sl4, ",", 0, NULL);
-  test_streq(joined, "Ambush,Anchorman,Anchorman,Bacon,Inhumane,Insurance,"
+  tt_str_op(joined,==, "Ambush,Anchorman,Anchorman,Bacon,Inhumane,Insurance,"
              "Knish,Know,Manners,Manners,Maraschinos,Wombats,Wombats");
   tor_free(joined);
 
@@ -538,12 +538,12 @@ test_container_bitarray(void)
   int i, j, ok=1;
 
   ba = bitarray_init_zero(1);
-  test_assert(ba);
-  test_assert(! bitarray_is_set(ba, 0));
+  tt_assert(ba);
+  tt_assert(! bitarray_is_set(ba, 0));
   bitarray_set(ba, 0);
-  test_assert(bitarray_is_set(ba, 0));
+  tt_assert(bitarray_is_set(ba, 0));
   bitarray_clear(ba, 0);
-  test_assert(! bitarray_is_set(ba, 0));
+  tt_assert(! bitarray_is_set(ba, 0));
   bitarray_free(ba);
 
   ba = bitarray_init_zero(1023);
@@ -558,7 +558,7 @@ test_container_bitarray(void)
       if (!bool_eq(bitarray_is_set(ba, j), j%i))
         ok = 0;
     }
-    test_assert(ok);
+    tt_assert(ok);
     if (i < 7)
       ++i;
     else if (i == 28)
@@ -592,19 +592,19 @@ test_container_digestset(void)
   SMARTLIST_FOREACH(included, const char *, cp,
                     if (digestset_contains(set, cp))
                       ok = 0);
-  test_assert(ok);
+  tt_assert(ok);
   SMARTLIST_FOREACH(included, const char *, cp,
                     digestset_add(set, cp));
   SMARTLIST_FOREACH(included, const char *, cp,
                     if (!digestset_contains(set, cp))
                       ok = 0);
-  test_assert(ok);
+  tt_assert(ok);
   for (i = 0; i < 1000; ++i) {
     crypto_rand(d, DIGEST_LEN);
     if (digestset_contains(set, d))
       ++false_positives;
   }
-  test_assert(false_positives < 50); /* Should be far lower. */
+  tt_int_op(50, >, false_positives); /* Should be far lower. */
 
  done:
   if (set)
@@ -665,31 +665,31 @@ test_container_pqueue(void)
 
   OK();
 
-  test_eq(smartlist_len(sl), 11);
-  test_eq_ptr(smartlist_get(sl, 0), &apples);
-  test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &apples);
-  test_eq(smartlist_len(sl), 10);
+  tt_int_op(smartlist_len(sl),==, 11);
+  tt_ptr_op(smartlist_get(sl, 0),==, &apples);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &apples);
+  tt_int_op(smartlist_len(sl),==, 10);
   OK();
-  test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &cows);
-  test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &daschunds);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &cows);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &daschunds);
   smartlist_pqueue_add(sl, cmp, offset, &chinchillas);
   OK();
   smartlist_pqueue_add(sl, cmp, offset, &fireflies);
   OK();
-  test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &chinchillas);
-  test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &eggplants);
-  test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &fireflies);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &chinchillas);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &eggplants);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &fireflies);
   OK();
-  test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &fish);
-  test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &frogs);
-  test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &lobsters);
-  test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &roquefort);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &fish);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &frogs);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &lobsters);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &roquefort);
   OK();
-  test_eq(smartlist_len(sl), 3);
-  test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &squid);
-  test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &weissbier);
-  test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &zebras);
-  test_eq(smartlist_len(sl), 0);
+  tt_int_op(smartlist_len(sl),==, 3);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &squid);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &weissbier);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &zebras);
+  tt_int_op(smartlist_len(sl),==, 0);
   OK();
 
   /* Now test remove. */
@@ -699,21 +699,21 @@ test_container_pqueue(void)
   smartlist_pqueue_add(sl, cmp, offset, &apples);
   smartlist_pqueue_add(sl, cmp, offset, &squid);
   smartlist_pqueue_add(sl, cmp, offset, &zebras);
-  test_eq(smartlist_len(sl), 6);
+  tt_int_op(smartlist_len(sl),==, 6);
   OK();
   smartlist_pqueue_remove(sl, cmp, offset, &zebras);
-  test_eq(smartlist_len(sl), 5);
+  tt_int_op(smartlist_len(sl),==, 5);
   OK();
   smartlist_pqueue_remove(sl, cmp, offset, &cows);
-  test_eq(smartlist_len(sl), 4);
+  tt_int_op(smartlist_len(sl),==, 4);
   OK();
   smartlist_pqueue_remove(sl, cmp, offset, &apples);
-  test_eq(smartlist_len(sl), 3);
+  tt_int_op(smartlist_len(sl),==, 3);
   OK();
-  test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &fish);
-  test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &frogs);
-  test_eq_ptr(smartlist_pqueue_pop(sl, cmp, offset), &squid);
-  test_eq(smartlist_len(sl), 0);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &fish);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &frogs);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &squid);
+  tt_int_op(smartlist_len(sl),==, 0);
   OK();
 
 #undef OK
@@ -743,31 +743,31 @@ test_container_strmap(void)
   char *v105 = tor_strdup("v105");
 
   map = strmap_new();
-  test_assert(map);
-  test_eq(strmap_size(map), 0);
-  test_assert(strmap_isempty(map));
+  tt_assert(map);
+  tt_int_op(strmap_size(map),==, 0);
+  tt_assert(strmap_isempty(map));
   v = strmap_set(map, "K1", v99);
-  test_eq_ptr(v, NULL);
-  test_assert(!strmap_isempty(map));
+  tt_ptr_op(v,==, NULL);
+  tt_assert(!strmap_isempty(map));
   v = strmap_set(map, "K2", v101);
-  test_eq_ptr(v, NULL);
+  tt_ptr_op(v,==, NULL);
   v = strmap_set(map, "K1", v100);
-  test_eq_ptr(v, v99);
-  test_eq_ptr(strmap_get(map,"K1"), v100);
-  test_eq_ptr(strmap_get(map,"K2"), v101);
-  test_eq_ptr(strmap_get(map,"K-not-there"), NULL);
+  tt_ptr_op(v,==, v99);
+  tt_ptr_op(strmap_get(map,"K1"),==, v100);
+  tt_ptr_op(strmap_get(map,"K2"),==, v101);
+  tt_ptr_op(strmap_get(map,"K-not-there"),==, NULL);
   strmap_assert_ok(map);
 
   v = strmap_remove(map,"K2");
   strmap_assert_ok(map);
-  test_eq_ptr(v, v101);
-  test_eq_ptr(strmap_get(map,"K2"), NULL);
-  test_eq_ptr(strmap_remove(map,"K2"), NULL);
+  tt_ptr_op(v,==, v101);
+  tt_ptr_op(strmap_get(map,"K2"),==, NULL);
+  tt_ptr_op(strmap_remove(map,"K2"),==, NULL);
 
   strmap_set(map, "K2", v101);
   strmap_set(map, "K3", v102);
   strmap_set(map, "K4", v103);
-  test_eq(strmap_size(map), 4);
+  tt_int_op(strmap_size(map),==, 4);
   strmap_assert_ok(map);
   strmap_set(map, "K5", v104);
   strmap_set(map, "K6", v105);
@@ -779,7 +779,7 @@ test_container_strmap(void)
   while (!strmap_iter_done(iter)) {
     strmap_iter_get(iter,&k,&v);
     smartlist_add(found_keys, tor_strdup(k));
-    test_eq_ptr(v, strmap_get(map, k));
+    tt_ptr_op(v,==, strmap_get(map, k));
 
     if (!strcmp(k, "K2")) {
       iter = strmap_iter_next_rmv(map,iter);
@@ -789,12 +789,12 @@ test_container_strmap(void)
   }
 
   /* Make sure we removed K2, but not the others. */
-  test_eq_ptr(strmap_get(map, "K2"), NULL);
-  test_eq_ptr(strmap_get(map, "K5"), v104);
+  tt_ptr_op(strmap_get(map, "K2"),==, NULL);
+  tt_ptr_op(strmap_get(map, "K5"),==, v104);
   /* Make sure we visited everyone once */
   smartlist_sort_strings(found_keys);
   visited = smartlist_join_strings(found_keys, ":", 0, NULL);
-  test_streq(visited, "K1:K2:K3:K4:K5:K6");
+  tt_str_op(visited,==, "K1:K2:K3:K4:K5:K6");
 
   strmap_assert_ok(map);
   /* Clean up after ourselves. */
@@ -804,13 +804,13 @@ test_container_strmap(void)
   /* Now try some lc functions. */
   map = strmap_new();
   strmap_set_lc(map,"Ab.C", v1);
-  test_eq_ptr(strmap_get(map,"ab.c"), v1);
+  tt_ptr_op(strmap_get(map,"ab.c"),==, v1);
   strmap_assert_ok(map);
-  test_eq_ptr(strmap_get_lc(map,"AB.C"), v1);
-  test_eq_ptr(strmap_get(map,"AB.C"), NULL);
-  test_eq_ptr(strmap_remove_lc(map,"aB.C"), v1);
+  tt_ptr_op(strmap_get_lc(map,"AB.C"),==, v1);
+  tt_ptr_op(strmap_get(map,"AB.C"),==, NULL);
+  tt_ptr_op(strmap_remove_lc(map,"aB.C"),==, v1);
   strmap_assert_ok(map);
-  test_eq_ptr(strmap_get_lc(map,"AB.C"), NULL);
+  tt_ptr_op(strmap_get_lc(map,"AB.C"),==, NULL);
 
  done:
   if (map)
@@ -841,41 +841,41 @@ test_container_order_functions(void)
 #define median() median_int(lst, n)
 
   lst[n++] = 12;
-  test_eq(12, median()); /* 12 */
+  tt_int_op(12,==, median()); /* 12 */
   lst[n++] = 77;
   //smartlist_shuffle(sl);
-  test_eq(12, median()); /* 12, 77 */
+  tt_int_op(12,==, median()); /* 12, 77 */
   lst[n++] = 77;
   //smartlist_shuffle(sl);
-  test_eq(77, median()); /* 12, 77, 77 */
+  tt_int_op(77,==, median()); /* 12, 77, 77 */
   lst[n++] = 24;
-  test_eq(24, median()); /* 12,24,77,77 */
+  tt_int_op(24,==, median()); /* 12,24,77,77 */
   lst[n++] = 60;
   lst[n++] = 12;
   lst[n++] = 25;
   //smartlist_shuffle(sl);
-  test_eq(25, median()); /* 12,12,24,25,60,77,77 */
+  tt_int_op(25,==, median()); /* 12,12,24,25,60,77,77 */
 #undef median
 
 #define third_quartile() third_quartile_uint32(lst2, n)
 
   n = 0;
   lst2[n++] = 1;
-  test_eq(1, third_quartile()); /* ~1~ */
+  tt_int_op(1,==, third_quartile()); /* ~1~ */
   lst2[n++] = 2;
-  test_eq(2, third_quartile()); /* 1, ~2~ */
+  tt_int_op(2,==, third_quartile()); /* 1, ~2~ */
   lst2[n++] = 3;
   lst2[n++] = 4;
   lst2[n++] = 5;
-  test_eq(4, third_quartile()); /* 1, 2, 3, ~4~, 5 */
+  tt_int_op(4,==, third_quartile()); /* 1, 2, 3, ~4~, 5 */
   lst2[n++] = 6;
   lst2[n++] = 7;
   lst2[n++] = 8;
   lst2[n++] = 9;
-  test_eq(7, third_quartile()); /* 1, 2, 3, 4, 5, 6, ~7~, 8, 9 */
+  tt_int_op(7,==, third_quartile()); /* 1, 2, 3, 4, 5, 6, ~7~, 8, 9 */
   lst2[n++] = 10;
   lst2[n++] = 11;
-  test_eq(9, third_quartile()); /* 1, 2, 3, 4, 5, 6, 7, 8, ~9~, 10, 11 */
+  tt_int_op(9,==, third_quartile()); /* 1, 2, 3, 4, 5, 6, 7, 8, ~9~, 10, 11 */
 
 #undef third_quartile
 
@@ -945,9 +945,9 @@ test_container_fp_pair_map(void)
   char *v105 = tor_strdup("v105");
 
   map = fp_pair_map_new();
-  test_assert(map);
-  test_eq(fp_pair_map_size(map), 0);
-  test_assert(fp_pair_map_isempty(map));
+  tt_assert(map);
+  tt_int_op(fp_pair_map_size(map),==, 0);
+  tt_assert(fp_pair_map_isempty(map));
 
   memset(fp1.first, 0x11, DIGEST_LEN);
   memset(fp1.second, 0x12, DIGEST_LEN);
@@ -964,26 +964,26 @@ test_container_fp_pair_map(void)
 
   v = fp_pair_map_set(map, &fp1, v99);
   tt_ptr_op(v, ==, NULL);
-  test_assert(!fp_pair_map_isempty(map));
+  tt_assert(!fp_pair_map_isempty(map));
   v = fp_pair_map_set(map, &fp2, v101);
   tt_ptr_op(v, ==, NULL);
   v = fp_pair_map_set(map, &fp1, v100);
   tt_ptr_op(v, ==, v99);
-  test_eq_ptr(fp_pair_map_get(map, &fp1), v100);
-  test_eq_ptr(fp_pair_map_get(map, &fp2), v101);
-  test_eq_ptr(fp_pair_map_get(map, &fp3), NULL);
+  tt_ptr_op(fp_pair_map_get(map, &fp1),==, v100);
+  tt_ptr_op(fp_pair_map_get(map, &fp2),==, v101);
+  tt_ptr_op(fp_pair_map_get(map, &fp3),==, NULL);
   fp_pair_map_assert_ok(map);
 
   v = fp_pair_map_remove(map, &fp2);
   fp_pair_map_assert_ok(map);
-  test_eq_ptr(v, v101);
-  test_eq_ptr(fp_pair_map_get(map, &fp2), NULL);
-  test_eq_ptr(fp_pair_map_remove(map, &fp2), NULL);
+  tt_ptr_op(v,==, v101);
+  tt_ptr_op(fp_pair_map_get(map, &fp2),==, NULL);
+  tt_ptr_op(fp_pair_map_remove(map, &fp2),==, NULL);
 
   fp_pair_map_set(map, &fp2, v101);
   fp_pair_map_set(map, &fp3, v102);
   fp_pair_map_set(map, &fp4, v103);
-  test_eq(fp_pair_map_size(map), 4);
+  tt_int_op(fp_pair_map_size(map),==, 4);
   fp_pair_map_assert_ok(map);
   fp_pair_map_set(map, &fp5, v104);
   fp_pair_map_set(map, &fp6, v105);
@@ -993,7 +993,7 @@ test_container_fp_pair_map(void)
   iter = fp_pair_map_iter_init(map);
   while (!fp_pair_map_iter_done(iter)) {
     fp_pair_map_iter_get(iter, &k, &v);
-    test_eq_ptr(v, fp_pair_map_get(map, &k));
+    tt_ptr_op(v,==, fp_pair_map_get(map, &k));
 
     if (tor_memeq(&fp2, &k, sizeof(fp2))) {
       iter = fp_pair_map_iter_next_rmv(map, iter);
@@ -1003,8 +1003,8 @@ test_container_fp_pair_map(void)
   }
 
   /* Make sure we removed fp2, but not the others. */
-  test_eq_ptr(fp_pair_map_get(map, &fp2), NULL);
-  test_eq_ptr(fp_pair_map_get(map, &fp5), v104);
+  tt_ptr_op(fp_pair_map_get(map, &fp2),==, NULL);
+  tt_ptr_op(fp_pair_map_get(map, &fp5),==, v104);
 
   fp_pair_map_assert_ok(map);
   /* Clean up after ourselves. */
diff --git a/src/test/test_crypto.c b/src/test/test_crypto.c
index 5d8edb6550..274a2687df 100644
--- a/src/test/test_crypto.c
+++ b/src/test/test_crypto.c
@@ -30,24 +30,24 @@ test_crypto_dh(void)
   char s2[DH_BYTES];
   ssize_t s1len, s2len;
 
-  test_eq(crypto_dh_get_bytes(dh1), DH_BYTES);
-  test_eq(crypto_dh_get_bytes(dh2), DH_BYTES);
+  tt_int_op(crypto_dh_get_bytes(dh1),==, DH_BYTES);
+  tt_int_op(crypto_dh_get_bytes(dh2),==, DH_BYTES);
 
   memset(p1, 0, DH_BYTES);
   memset(p2, 0, DH_BYTES);
-  test_memeq(p1, p2, DH_BYTES);
-  test_assert(! crypto_dh_get_public(dh1, p1, DH_BYTES));
-  test_memneq(p1, p2, DH_BYTES);
-  test_assert(! crypto_dh_get_public(dh2, p2, DH_BYTES));
-  test_memneq(p1, p2, DH_BYTES);
+  tt_mem_op(p1,==, p2, DH_BYTES);
+  tt_assert(! crypto_dh_get_public(dh1, p1, DH_BYTES));
+  tt_mem_op(p1,!=, p2, DH_BYTES);
+  tt_assert(! crypto_dh_get_public(dh2, p2, DH_BYTES));
+  tt_mem_op(p1,!=, p2, DH_BYTES);
 
   memset(s1, 0, DH_BYTES);
   memset(s2, 0xFF, DH_BYTES);
   s1len = crypto_dh_compute_secret(LOG_WARN, dh1, p2, DH_BYTES, s1, 50);
   s2len = crypto_dh_compute_secret(LOG_WARN, dh2, p1, DH_BYTES, s2, 50);
-  test_assert(s1len > 0);
-  test_eq(s1len, s2len);
-  test_memeq(s1, s2, s1len);
+  tt_assert(s1len > 0);
+  tt_int_op(s1len,==, s2len);
+  tt_mem_op(s1,==, s2, s1len);
 
   {
     /* XXXX Now fabricate some bad values and make sure they get caught,
@@ -70,10 +70,10 @@ test_crypto_rng(void)
   double d;
 
   /* Try out RNG. */
-  test_assert(! crypto_seed_rng(0));
+  tt_assert(! crypto_seed_rng(0));
   crypto_rand(data1, 100);
   crypto_rand(data2, 100);
-  test_memneq(data1,data2,100);
+  tt_mem_op(data1,!=, data2,100);
   allok = 1;
   for (i = 0; i < 100; ++i) {
     uint64_t big;
@@ -88,8 +88,8 @@ test_crypto_rng(void)
     if (big >= 5)
       allok = 0;
     d = crypto_rand_double();
-    test_assert(d >= 0);
-    test_assert(d < 1.0);
+    tt_assert(d >= 0);
+    tt_assert(d < 1.0);
     host = crypto_random_hostname(3,8,"www.",".onion");
     if (strcmpstart(host,"www.") ||
         strcmpend(host,".onion") ||
@@ -98,7 +98,7 @@ test_crypto_rng(void)
       allok = 0;
     tor_free(host);
   }
-  test_assert(allok);
+  tt_assert(allok);
  done:
   ;
 }
@@ -135,8 +135,8 @@ test_crypto_aes(void *arg)
   /* Try encrypting 512 chars. */
   crypto_cipher_encrypt(env1, data2, data1, 512);
   crypto_cipher_decrypt(env2, data3, data2, 512);
-  test_memeq(data1, data3, 512);
-  test_memneq(data1, data2, 512);
+  tt_mem_op(data1,==, data3, 512);
+  tt_mem_op(data1,!=, data2, 512);
 
   /* Now encrypt 1 at a time, and get 1 at a time. */
   for (j = 512; j < 560; ++j) {
@@ -145,7 +145,7 @@ test_crypto_aes(void *arg)
   for (j = 512; j < 560; ++j) {
     crypto_cipher_decrypt(env2, data3+j, data2+j, 1);
   }
-  test_memeq(data1, data3, 560);
+  tt_mem_op(data1,==, data3, 560);
   /* Now encrypt 3 at a time, and get 5 at a time. */
   for (j = 560; j < 1024-5; j += 3) {
     crypto_cipher_encrypt(env1, data2+j, data1+j, 3);
@@ -153,7 +153,7 @@ test_crypto_aes(void *arg)
   for (j = 560; j < 1024-5; j += 5) {
     crypto_cipher_decrypt(env2, data3+j, data2+j, 5);
   }
-  test_memeq(data1, data3, 1024-5);
+  tt_mem_op(data1,==, data3, 1024-5);
   /* Now make sure that when we encrypt with different chunk sizes, we get
      the same results. */
   crypto_cipher_free(env2);
@@ -170,7 +170,7 @@ test_crypto_aes(void *arg)
       printf("%d:  %d\t%d\n", j, (int) data2[j], (int) data3[j]);
     }
   }
-  test_memeq(data2, data3, 1024-16);
+  tt_mem_op(data2,==, data3, 1024-16);
   crypto_cipher_free(env1);
   env1 = NULL;
   crypto_cipher_free(env2);
@@ -237,7 +237,7 @@ test_crypto_aes(void *arg)
                                    "\xff\xff\xff\xff\xff\xff\xff\xff"
                                    "\xff\xff\xff\xff\xff\xff\xff\xff");
   crypto_cipher_crypt_inplace(env1, data2, 64);
-  test_assert(tor_mem_is_zero(data2, 64));
+  tt_assert(tor_mem_is_zero(data2, 64));
 
  done:
   tor_free(mem_op_hex_tmp);
@@ -277,13 +277,13 @@ test_crypto_sha(void)
 
   /* Case empty (wikipedia) */
   crypto_hmac_sha256(digest, "", 0, "", 0);
-  test_streq(hex_str(digest, 32),
+  tt_str_op(hex_str(digest, 32),==,
            "B613679A0814D9EC772F95D778C35FC5FF1697C493715653C6C712144292C5AD");
 
   /* Case quick-brown (wikipedia) */
   crypto_hmac_sha256(digest, "key", 3,
                      "The quick brown fox jumps over the lazy dog", 43);
-  test_streq(hex_str(digest, 32),
+  tt_str_op(hex_str(digest, 32),==,
            "F7BC83F430538424B13298E6AA6FB143EF4D59A14946175997479DBC2D1A3CD8");
 
   /* "Test Case 1" from RFC 4231 */
@@ -344,43 +344,43 @@ test_crypto_sha(void)
 
   /* Incremental digest code. */
   d1 = crypto_digest_new();
-  test_assert(d1);
+  tt_assert(d1);
   crypto_digest_add_bytes(d1, "abcdef", 6);
   d2 = crypto_digest_dup(d1);
-  test_assert(d2);
+  tt_assert(d2);
   crypto_digest_add_bytes(d2, "ghijkl", 6);
   crypto_digest_get_digest(d2, d_out1, sizeof(d_out1));
   crypto_digest(d_out2, "abcdefghijkl", 12);
-  test_memeq(d_out1, d_out2, DIGEST_LEN);
+  tt_mem_op(d_out1,==, d_out2, DIGEST_LEN);
   crypto_digest_assign(d2, d1);
   crypto_digest_add_bytes(d2, "mno", 3);
   crypto_digest_get_digest(d2, d_out1, sizeof(d_out1));
   crypto_digest(d_out2, "abcdefmno", 9);
-  test_memeq(d_out1, d_out2, DIGEST_LEN);
+  tt_mem_op(d_out1,==, d_out2, DIGEST_LEN);
   crypto_digest_get_digest(d1, d_out1, sizeof(d_out1));
   crypto_digest(d_out2, "abcdef", 6);
-  test_memeq(d_out1, d_out2, DIGEST_LEN);
+  tt_mem_op(d_out1,==, d_out2, DIGEST_LEN);
   crypto_digest_free(d1);
   crypto_digest_free(d2);
 
   /* Incremental digest code with sha256 */
   d1 = crypto_digest256_new(DIGEST_SHA256);
-  test_assert(d1);
+  tt_assert(d1);
   crypto_digest_add_bytes(d1, "abcdef", 6);
   d2 = crypto_digest_dup(d1);
-  test_assert(d2);
+  tt_assert(d2);
   crypto_digest_add_bytes(d2, "ghijkl", 6);
   crypto_digest_get_digest(d2, d_out1, sizeof(d_out1));
   crypto_digest256(d_out2, "abcdefghijkl", 12, DIGEST_SHA256);
-  test_memeq(d_out1, d_out2, DIGEST_LEN);
+  tt_mem_op(d_out1,==, d_out2, DIGEST_LEN);
   crypto_digest_assign(d2, d1);
   crypto_digest_add_bytes(d2, "mno", 3);
   crypto_digest_get_digest(d2, d_out1, sizeof(d_out1));
   crypto_digest256(d_out2, "abcdefmno", 9, DIGEST_SHA256);
-  test_memeq(d_out1, d_out2, DIGEST_LEN);
+  tt_mem_op(d_out1,==, d_out2, DIGEST_LEN);
   crypto_digest_get_digest(d1, d_out1, sizeof(d_out1));
   crypto_digest256(d_out2, "abcdef", 6, DIGEST_SHA256);
-  test_memeq(d_out1, d_out2, DIGEST_LEN);
+  tt_mem_op(d_out1,==, d_out2, DIGEST_LEN);
 
  done:
   if (d1)
@@ -403,72 +403,72 @@ test_crypto_pk(void)
   /* Public-key ciphers */
   pk1 = pk_generate(0);
   pk2 = crypto_pk_new();
-  test_assert(pk1 && pk2);
-  test_assert(! crypto_pk_write_public_key_to_string(pk1, &encoded, &size));
-  test_assert(! crypto_pk_read_public_key_from_string(pk2, encoded, size));
-  test_eq(0, crypto_pk_cmp_keys(pk1, pk2));
+  tt_assert(pk1 && pk2);
+  tt_assert(! crypto_pk_write_public_key_to_string(pk1, &encoded, &size));
+  tt_assert(! crypto_pk_read_public_key_from_string(pk2, encoded, size));
+  tt_int_op(0,==, crypto_pk_cmp_keys(pk1, pk2));
 
   /* comparison between keys and NULL */
   tt_int_op(crypto_pk_cmp_keys(NULL, pk1), <, 0);
   tt_int_op(crypto_pk_cmp_keys(NULL, NULL), ==, 0);
   tt_int_op(crypto_pk_cmp_keys(pk1, NULL), >, 0);
 
-  test_eq(128, crypto_pk_keysize(pk1));
-  test_eq(1024, crypto_pk_num_bits(pk1));
-  test_eq(128, crypto_pk_keysize(pk2));
-  test_eq(1024, crypto_pk_num_bits(pk2));
+  tt_int_op(128,==, crypto_pk_keysize(pk1));
+  tt_int_op(1024,==, crypto_pk_num_bits(pk1));
+  tt_int_op(128,==, crypto_pk_keysize(pk2));
+  tt_int_op(1024,==, crypto_pk_num_bits(pk2));
 
-  test_eq(128, crypto_pk_public_encrypt(pk2, data1, sizeof(data1),
+  tt_int_op(128,==, crypto_pk_public_encrypt(pk2, data1, sizeof(data1),
                                         "Hello whirled.", 15,
                                         PK_PKCS1_OAEP_PADDING));
-  test_eq(128, crypto_pk_public_encrypt(pk1, data2, sizeof(data1),
+  tt_int_op(128,==, crypto_pk_public_encrypt(pk1, data2, sizeof(data1),
                                         "Hello whirled.", 15,
                                         PK_PKCS1_OAEP_PADDING));
   /* oaep padding should make encryption not match */
-  test_memneq(data1, data2, 128);
-  test_eq(15, crypto_pk_private_decrypt(pk1, data3, sizeof(data3), data1, 128,
+  tt_mem_op(data1,!=, data2, 128);
+  tt_int_op(15,==, crypto_pk_private_decrypt(pk1, data3, sizeof(data3), data1, 128,
                                         PK_PKCS1_OAEP_PADDING,1));
-  test_streq(data3, "Hello whirled.");
+  tt_str_op(data3,==, "Hello whirled.");
   memset(data3, 0, 1024);
-  test_eq(15, crypto_pk_private_decrypt(pk1, data3, sizeof(data3), data2, 128,
+  tt_int_op(15,==, crypto_pk_private_decrypt(pk1, data3, sizeof(data3), data2, 128,
                                         PK_PKCS1_OAEP_PADDING,1));
-  test_streq(data3, "Hello whirled.");
+  tt_str_op(data3,==, "Hello whirled.");
   /* Can't decrypt with public key. */
-  test_eq(-1, crypto_pk_private_decrypt(pk2, data3, sizeof(data3), data2, 128,
+  tt_int_op(-1,==, crypto_pk_private_decrypt(pk2, data3, sizeof(data3), data2, 128,
                                         PK_PKCS1_OAEP_PADDING,1));
   /* Try again with bad padding */
   memcpy(data2+1, "XYZZY", 5);  /* This has fails ~ once-in-2^40 */
-  test_eq(-1, crypto_pk_private_decrypt(pk1, data3, sizeof(data3), data2, 128,
+  tt_int_op(-1,==, crypto_pk_private_decrypt(pk1, data3, sizeof(data3), data2, 128,
                                         PK_PKCS1_OAEP_PADDING,1));
 
   /* File operations: save and load private key */
-  test_assert(! crypto_pk_write_private_key_to_filename(pk1,
+  tt_assert(! crypto_pk_write_private_key_to_filename(pk1,
                                                         get_fname("pkey1")));
   /* failing case for read: can't read. */
-  test_assert(crypto_pk_read_private_key_from_filename(pk2,
+  tt_assert(crypto_pk_read_private_key_from_filename(pk2,
                                                    get_fname("xyzzy")) < 0);
   write_str_to_file(get_fname("xyzzy"), "foobar", 6);
   /* Failing case for read: no key. */
-  test_assert(crypto_pk_read_private_key_from_filename(pk2,
+  tt_assert(crypto_pk_read_private_key_from_filename(pk2,
                                                    get_fname("xyzzy")) < 0);
-  test_assert(! crypto_pk_read_private_key_from_filename(pk2,
+  tt_assert(! crypto_pk_read_private_key_from_filename(pk2,
                                                          get_fname("pkey1")));
-  test_eq(15, crypto_pk_private_decrypt(pk2, data3, sizeof(data3), data1, 128,
+  tt_int_op(15,==, crypto_pk_private_decrypt(pk2, data3, sizeof(data3), data1, 128,
                                         PK_PKCS1_OAEP_PADDING,1));
 
   /* Now try signing. */
   strlcpy(data1, "Ossifrage", 1024);
-  test_eq(128, crypto_pk_private_sign(pk1, data2, sizeof(data2), data1, 10));
-  test_eq(10,
+  tt_int_op(128,==, crypto_pk_private_sign(pk1, data2, sizeof(data2), data1, 10));
+  tt_int_op(10,==,
           crypto_pk_public_checksig(pk1, data3, sizeof(data3), data2, 128));
-  test_streq(data3, "Ossifrage");
+  tt_str_op(data3,==, "Ossifrage");
   /* Try signing digests. */
-  test_eq(128, crypto_pk_private_sign_digest(pk1, data2, sizeof(data2),
+  tt_int_op(128,==, crypto_pk_private_sign_digest(pk1, data2, sizeof(data2),
                                              data1, 10));
-  test_eq(20,
+  tt_int_op(20,==,
           crypto_pk_public_checksig(pk1, data3, sizeof(data3), data2, 128));
-  test_eq(0, crypto_pk_public_checksig_digest(pk1, data1, 10, data2, 128));
-  test_eq(-1, crypto_pk_public_checksig_digest(pk1, data1, 11, data2, 128));
+  tt_int_op(0,==, crypto_pk_public_checksig_digest(pk1, data1, 10, data2, 128));
+  tt_int_op(-1,==, crypto_pk_public_checksig_digest(pk1, data1, 11, data2, 128));
 
   /*XXXX test failed signing*/
 
@@ -476,9 +476,9 @@ test_crypto_pk(void)
   crypto_pk_free(pk2);
   pk2 = NULL;
   i = crypto_pk_asn1_encode(pk1, data1, 1024);
-  test_assert(i>0);
+  tt_int_op(i, >, 0);
   pk2 = crypto_pk_asn1_decode(data1, i);
-  test_assert(crypto_pk_cmp_keys(pk1,pk2) == 0);
+  tt_assert(crypto_pk_cmp_keys(pk1,pk2) == 0);
 
   /* Try with hybrid encryption wrappers. */
   crypto_rand(data1, 1024);
@@ -487,19 +487,19 @@ test_crypto_pk(void)
     memset(data3,0,1024);
     len = crypto_pk_public_hybrid_encrypt(pk1,data2,sizeof(data2),
                                           data1,i,PK_PKCS1_OAEP_PADDING,0);
-    test_assert(len>=0);
+    tt_int_op(len, >=, 0);
     len = crypto_pk_private_hybrid_decrypt(pk1,data3,sizeof(data3),
                                            data2,len,PK_PKCS1_OAEP_PADDING,1);
-    test_eq(len,i);
-    test_memeq(data1,data3,i);
+    tt_int_op(len,==, i);
+    tt_mem_op(data1,==, data3,i);
   }
 
   /* Try copy_full */
   crypto_pk_free(pk2);
   pk2 = crypto_pk_copy_full(pk1);
-  test_assert(pk2 != NULL);
+  tt_assert(pk2 != NULL);
   test_neq_ptr(pk1, pk2);
-  test_assert(crypto_pk_cmp_keys(pk1,pk2) == 0);
+  tt_assert(crypto_pk_cmp_keys(pk1,pk2) == 0);
 
  done:
   if (pk1)
@@ -532,7 +532,7 @@ test_crypto_pk_fingerprints(void *arg)
   /* Is digest as expected? */
   crypto_digest(d, encoded, n);
   tt_int_op(0, ==, crypto_pk_get_digest(pk, d2));
-  test_memeq(d, d2, DIGEST_LEN);
+  tt_mem_op(d,==, d2, DIGEST_LEN);
 
   /* Is fingerprint right? */
   tt_int_op(0, ==, crypto_pk_get_fingerprint(pk, fingerprint, 0));
@@ -569,20 +569,20 @@ test_crypto_digests(void)
   char digest[DIGEST_LEN];
 
   k = crypto_pk_new();
-  test_assert(k);
+  tt_assert(k);
   r = crypto_pk_read_private_key_from_string(k, AUTHORITY_SIGNKEY_3, -1);
-  test_assert(!r);
+  tt_assert(!r);
 
   r = crypto_pk_get_digest(k, digest);
-  test_assert(r == 0);
-  test_memeq(hex_str(digest, DIGEST_LEN),
+  tt_assert(r == 0);
+  tt_mem_op(hex_str(digest, DIGEST_LEN),==,
              AUTHORITY_SIGNKEY_A_DIGEST, HEX_DIGEST_LEN);
 
   r = crypto_pk_get_all_digests(k, &pkey_digests);
 
-  test_memeq(hex_str(pkey_digests.d[DIGEST_SHA1], DIGEST_LEN),
+  tt_mem_op(hex_str(pkey_digests.d[DIGEST_SHA1], DIGEST_LEN),==,
              AUTHORITY_SIGNKEY_A_DIGEST, HEX_DIGEST_LEN);
-  test_memeq(hex_str(pkey_digests.d[DIGEST_SHA256], DIGEST256_LEN),
+  tt_mem_op(hex_str(pkey_digests.d[DIGEST_SHA256], DIGEST256_LEN),==,
              AUTHORITY_SIGNKEY_A_DIGEST256, HEX_DIGEST256_LEN);
  done:
   crypto_pk_free(k);
@@ -599,50 +599,50 @@ test_crypto_formats(void)
   data1 = tor_malloc(1024);
   data2 = tor_malloc(1024);
   data3 = tor_malloc(1024);
-  test_assert(data1 && data2 && data3);
+  tt_assert(data1 && data2 && data3);
 
   /* Base64 tests */
   memset(data1, 6, 1024);
   for (idx = 0; idx < 10; ++idx) {
     i = base64_encode(data2, 1024, data1, idx);
-    test_assert(i >= 0);
+    tt_int_op(i, >=, 0);
     j = base64_decode(data3, 1024, data2, i);
-    test_eq(j,idx);
-    test_memeq(data3, data1, idx);
+    tt_int_op(j,==, idx);
+    tt_mem_op(data3,==, data1, idx);
   }
 
   strlcpy(data1, "Test string that contains 35 chars.", 1024);
   strlcat(data1, " 2nd string that contains 35 chars.", 1024);
 
   i = base64_encode(data2, 1024, data1, 71);
-  test_assert(i >= 0);
+  tt_int_op(i, >=, 0);
   j = base64_decode(data3, 1024, data2, i);
-  test_eq(j, 71);
-  test_streq(data3, data1);
-  test_assert(data2[i] == '\0');
+  tt_int_op(j,==, 71);
+  tt_str_op(data3,==, data1);
+  tt_int_op(data2[i], ==, '\0');
 
   crypto_rand(data1, DIGEST_LEN);
   memset(data2, 100, 1024);
   digest_to_base64(data2, data1);
-  test_eq(BASE64_DIGEST_LEN, strlen(data2));
-  test_eq(100, data2[BASE64_DIGEST_LEN+2]);
+  tt_int_op(BASE64_DIGEST_LEN,==, strlen(data2));
+  tt_int_op(100,==, data2[BASE64_DIGEST_LEN+2]);
   memset(data3, 99, 1024);
-  test_eq(digest_from_base64(data3, data2), 0);
-  test_memeq(data1, data3, DIGEST_LEN);
-  test_eq(99, data3[DIGEST_LEN+1]);
+  tt_int_op(digest_from_base64(data3, data2),==, 0);
+  tt_mem_op(data1,==, data3, DIGEST_LEN);
+  tt_int_op(99,==, data3[DIGEST_LEN+1]);
 
-  test_assert(digest_from_base64(data3, "###") < 0);
+  tt_assert(digest_from_base64(data3, "###") < 0);
 
   /* Encoding SHA256 */
   crypto_rand(data2, DIGEST256_LEN);
   memset(data2, 100, 1024);
   digest256_to_base64(data2, data1);
-  test_eq(BASE64_DIGEST256_LEN, strlen(data2));
-  test_eq(100, data2[BASE64_DIGEST256_LEN+2]);
+  tt_int_op(BASE64_DIGEST256_LEN,==, strlen(data2));
+  tt_int_op(100,==, data2[BASE64_DIGEST256_LEN+2]);
   memset(data3, 99, 1024);
-  test_eq(digest256_from_base64(data3, data2), 0);
-  test_memeq(data1, data3, DIGEST256_LEN);
-  test_eq(99, data3[DIGEST256_LEN+1]);
+  tt_int_op(digest256_from_base64(data3, data2),==, 0);
+  tt_mem_op(data1,==, data3, DIGEST256_LEN);
+  tt_int_op(99,==, data3[DIGEST256_LEN+1]);
 
   /* Base32 tests */
   strlcpy(data1, "5chrs", 1024);
@@ -651,27 +651,27 @@ test_crypto_formats(void)
    * By 5s: [00110 10101 10001 10110 10000 11100 10011 10011]
    */
   base32_encode(data2, 9, data1, 5);
-  test_streq(data2, "gvrwq4tt");
+  tt_str_op(data2,==, "gvrwq4tt");
 
   strlcpy(data1, "\xFF\xF5\x6D\x44\xAE\x0D\x5C\xC9\x62\xC4", 1024);
   base32_encode(data2, 30, data1, 10);
-  test_streq(data2, "772w2rfobvomsywe");
+  tt_str_op(data2,==, "772w2rfobvomsywe");
 
   /* Base16 tests */
   strlcpy(data1, "6chrs\xff", 1024);
   base16_encode(data2, 13, data1, 6);
-  test_streq(data2, "3663687273FF");
+  tt_str_op(data2,==, "3663687273FF");
 
   strlcpy(data1, "f0d678affc000100", 1024);
   i = base16_decode(data2, 8, data1, 16);
-  test_eq(i,0);
-  test_memeq(data2, "\xf0\xd6\x78\xaf\xfc\x00\x01\x00",8);
+  tt_int_op(i,==, 0);
+  tt_mem_op(data2,==, "\xf0\xd6\x78\xaf\xfc\x00\x01\x00",8);
 
   /* now try some failing base16 decodes */
-  test_eq(-1, base16_decode(data2, 8, data1, 15)); /* odd input len */
-  test_eq(-1, base16_decode(data2, 7, data1, 16)); /* dest too short */
+  tt_int_op(-1,==, base16_decode(data2, 8, data1, 15)); /* odd input len */
+  tt_int_op(-1,==, base16_decode(data2, 7, data1, 16)); /* dest too short */
   strlcpy(data1, "f0dz!8affc000100", 1024);
-  test_eq(-1, base16_decode(data2, 8, data1, 16));
+  tt_int_op(-1,==, base16_decode(data2, 8, data1, 16));
 
   tor_free(data1);
   tor_free(data2);
@@ -680,10 +680,10 @@ test_crypto_formats(void)
   /* Add spaces to fingerprint */
   {
     data1 = tor_strdup("ABCD1234ABCD56780000ABCD1234ABCD56780000");
-    test_eq(strlen(data1), 40);
+    tt_int_op(strlen(data1),==, 40);
     data2 = tor_malloc(FINGERPRINT_LEN+1);
     crypto_add_spaces_to_fp(data2, FINGERPRINT_LEN+1, data1);
-    test_streq(data2, "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 0000");
+    tt_str_op(data2,==, "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 0000");
     tor_free(data1);
     tor_free(data2);
   }
@@ -710,7 +710,7 @@ test_crypto_s2k(void)
 
   secret_to_key(buf+9, 20, "", 0, buf);
   crypto_digest(buf2+9, buf3, 1024);
-  test_memeq(buf, buf2, 29);
+  tt_mem_op(buf,==, buf2, 29);
 
   memcpy(buf,"vrbacrda",8);
   memcpy(buf2,"vrbacrda",8);
@@ -721,7 +721,7 @@ test_crypto_s2k(void)
     memcpy(buf3+i, "vrbacrda12345678", 16);
   }
   crypto_digest(buf2+9, buf3, 65536);
-  test_memeq(buf, buf2, 29);
+  tt_mem_op(buf,==, buf2, 29);
 
  done:
   tor_free(buf3);
@@ -757,79 +757,79 @@ test_crypto_aes_iv(void *arg)
   encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted1, 16 + 4095,
                                                  plain, 4095);
 
-  test_eq(encrypted_size, 16 + 4095);
+  tt_int_op(encrypted_size,==, 16 + 4095);
   tt_assert(encrypted_size > 0); /* This is obviously true, since 4111 is
                                    * greater than 0, but its truth is not
                                    * obvious to all analysis tools. */
   decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 4095,
                                              encrypted1, encrypted_size);
 
-  test_eq(decrypted_size, 4095);
+  tt_int_op(decrypted_size,==, 4095);
   tt_assert(decrypted_size > 0);
-  test_memeq(plain, decrypted1, 4095);
+  tt_mem_op(plain,==, decrypted1, 4095);
   /* Encrypt a second time (with a new random initialization vector). */
   encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted2, 16 + 4095,
                                              plain, 4095);
 
-  test_eq(encrypted_size, 16 + 4095);
+  tt_int_op(encrypted_size,==, 16 + 4095);
   tt_assert(encrypted_size > 0);
   decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted2, 4095,
                                              encrypted2, encrypted_size);
-  test_eq(decrypted_size, 4095);
+  tt_int_op(decrypted_size,==, 4095);
   tt_assert(decrypted_size > 0);
-  test_memeq(plain, decrypted2, 4095);
-  test_memneq(encrypted1, encrypted2, encrypted_size);
+  tt_mem_op(plain,==, decrypted2, 4095);
+  tt_mem_op(encrypted1,!=, encrypted2, encrypted_size);
   /* Decrypt with the wrong key. */
   decrypted_size = crypto_cipher_decrypt_with_iv(key2, decrypted2, 4095,
                                              encrypted1, encrypted_size);
-  test_eq(decrypted_size, 4095);
-  test_memneq(plain, decrypted2, decrypted_size);
+  tt_int_op(decrypted_size,==, 4095);
+  tt_mem_op(plain,!=, decrypted2, decrypted_size);
   /* Alter the initialization vector. */
   encrypted1[0] += 42;
   decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 4095,
                                              encrypted1, encrypted_size);
-  test_eq(decrypted_size, 4095);
-  test_memneq(plain, decrypted2, 4095);
+  tt_int_op(decrypted_size,==, 4095);
+  tt_mem_op(plain,!=, decrypted2, 4095);
   /* Special length case: 1. */
   encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted1, 16 + 1,
                                              plain_1, 1);
-  test_eq(encrypted_size, 16 + 1);
+  tt_int_op(encrypted_size,==, 16 + 1);
   tt_assert(encrypted_size > 0);
   decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 1,
                                              encrypted1, encrypted_size);
-  test_eq(decrypted_size, 1);
+  tt_int_op(decrypted_size,==, 1);
   tt_assert(decrypted_size > 0);
-  test_memeq(plain_1, decrypted1, 1);
+  tt_mem_op(plain_1,==, decrypted1, 1);
   /* Special length case: 15. */
   encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted1, 16 + 15,
                                              plain_15, 15);
-  test_eq(encrypted_size, 16 + 15);
+  tt_int_op(encrypted_size,==, 16 + 15);
   tt_assert(encrypted_size > 0);
   decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 15,
                                              encrypted1, encrypted_size);
-  test_eq(decrypted_size, 15);
+  tt_int_op(decrypted_size,==, 15);
   tt_assert(decrypted_size > 0);
-  test_memeq(plain_15, decrypted1, 15);
+  tt_mem_op(plain_15,==, decrypted1, 15);
   /* Special length case: 16. */
   encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted1, 16 + 16,
                                              plain_16, 16);
-  test_eq(encrypted_size, 16 + 16);
+  tt_int_op(encrypted_size,==, 16 + 16);
   tt_assert(encrypted_size > 0);
   decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 16,
                                              encrypted1, encrypted_size);
-  test_eq(decrypted_size, 16);
+  tt_int_op(decrypted_size,==, 16);
   tt_assert(decrypted_size > 0);
-  test_memeq(plain_16, decrypted1, 16);
+  tt_mem_op(plain_16,==, decrypted1, 16);
   /* Special length case: 17. */
   encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted1, 16 + 17,
                                              plain_17, 17);
-  test_eq(encrypted_size, 16 + 17);
+  tt_int_op(encrypted_size,==, 16 + 17);
   tt_assert(encrypted_size > 0);
   decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 17,
                                              encrypted1, encrypted_size);
-  test_eq(decrypted_size, 17);
+  tt_int_op(decrypted_size,==, 17);
   tt_assert(decrypted_size > 0);
-  test_memeq(plain_17, decrypted1, 17);
+  tt_mem_op(plain_17,==, decrypted1, 17);
 
  done:
   /* Free memory. */
@@ -850,26 +850,26 @@ test_crypto_base32_decode(void)
   /* Encode and decode a random string. */
   base32_encode(encoded, 96 + 1, plain, 60);
   res = base32_decode(decoded, 60, encoded, 96);
-  test_eq(res, 0);
-  test_memeq(plain, decoded, 60);
+  tt_int_op(res,==, 0);
+  tt_mem_op(plain,==, decoded, 60);
   /* Encode, uppercase, and decode a random string. */
   base32_encode(encoded, 96 + 1, plain, 60);
   tor_strupper(encoded);
   res = base32_decode(decoded, 60, encoded, 96);
-  test_eq(res, 0);
-  test_memeq(plain, decoded, 60);
+  tt_int_op(res,==, 0);
+  tt_mem_op(plain,==, decoded, 60);
   /* Change encoded string and decode. */
   if (encoded[0] == 'A' || encoded[0] == 'a')
     encoded[0] = 'B';
   else
     encoded[0] = 'A';
   res = base32_decode(decoded, 60, encoded, 96);
-  test_eq(res, 0);
-  test_memneq(plain, decoded, 60);
+  tt_int_op(res,==, 0);
+  tt_mem_op(plain,!=, decoded, 60);
   /* Bad encodings. */
   encoded[0] = '!';
   res = base32_decode(decoded, 60, encoded, 96);
-  test_assert(res < 0);
+  tt_int_op(0, >, res);
 
  done:
   ;
@@ -1024,7 +1024,7 @@ test_crypto_curve25519_impl(void *arg)
       e2k[31] |= (byte & 0x80);
     }
     curve25519_impl(e1e2k,e1,e2k);
-    test_memeq(e1e2k, e2e1k, 32);
+    tt_mem_op(e1e2k,==, e2e1k, 32);
     if (loop == loop_max-1) {
       break;
     }
@@ -1056,11 +1056,11 @@ test_crypto_curve25519_wrappers(void *arg)
   curve25519_secret_key_generate(&seckey2, 1);
   curve25519_public_key_generate(&pubkey1, &seckey1);
   curve25519_public_key_generate(&pubkey2, &seckey2);
-  test_assert(curve25519_public_key_is_ok(&pubkey1));
-  test_assert(curve25519_public_key_is_ok(&pubkey2));
+  tt_assert(curve25519_public_key_is_ok(&pubkey1));
+  tt_assert(curve25519_public_key_is_ok(&pubkey2));
   curve25519_handshake(output1, &seckey1, &pubkey2);
   curve25519_handshake(output2, &seckey2, &pubkey1);
-  test_memeq(output1, output2, sizeof(output1));
+  tt_mem_op(output1,==, output2, sizeof(output1));
 
  done:
   ;
@@ -1081,12 +1081,12 @@ test_crypto_curve25519_encode(void *arg)
   tt_int_op(CURVE25519_BASE64_PADDED_LEN, ==, strlen(buf));
 
   tt_int_op(0, ==, curve25519_public_from_base64(&key2, buf));
-  test_memeq(key1.public_key, key2.public_key, CURVE25519_PUBKEY_LEN);
+  tt_mem_op(key1.public_key,==, key2.public_key, CURVE25519_PUBKEY_LEN);
 
   buf[CURVE25519_BASE64_PADDED_LEN - 1] = '\0';
   tt_int_op(CURVE25519_BASE64_PADDED_LEN-1, ==, strlen(buf));
   tt_int_op(0, ==, curve25519_public_from_base64(&key3, buf));
-  test_memeq(key1.public_key, key3.public_key, CURVE25519_PUBKEY_LEN);
+  tt_mem_op(key1.public_key,==, key3.public_key, CURVE25519_PUBKEY_LEN);
 
   /* Now try bogus parses. */
   strlcpy(buf, "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$=", sizeof(buf));
@@ -1122,10 +1122,10 @@ test_crypto_curve25519_persist(void *arg)
   tt_str_op(tag,==,"testing");
   tor_free(tag);
 
-  test_memeq(keypair.pubkey.public_key,
+  tt_mem_op(keypair.pubkey.public_key,==,
              keypair2.pubkey.public_key,
              CURVE25519_PUBKEY_LEN);
-  test_memeq(keypair.seckey.secret_key,
+  tt_mem_op(keypair.seckey.secret_key,==,
              keypair2.seckey.secret_key,
              CURVE25519_SECKEY_LEN);
 
@@ -1137,11 +1137,11 @@ test_crypto_curve25519_persist(void *arg)
   tt_assert(fast_memeq(content, "== c25519v1: testing ==", taglen));
   tt_assert(tor_mem_is_zero(content+taglen, 32-taglen));
   cp = content + 32;
-  test_memeq(keypair.seckey.secret_key,
+  tt_mem_op(keypair.seckey.secret_key,==,
              cp,
              CURVE25519_SECKEY_LEN);
   cp += CURVE25519_SECKEY_LEN;
-  test_memeq(keypair.pubkey.public_key,
+  tt_mem_op(keypair.pubkey.public_key,==,
              cp,
              CURVE25519_SECKEY_LEN);
 
diff --git a/src/test/test_dir.c b/src/test/test_dir.c
index d66a3f8162..96acc7bf61 100644
--- a/src/test/test_dir.c
+++ b/src/test/test_dir.c
@@ -27,46 +27,46 @@
 static void
 test_dir_nicknames(void)
 {
-  test_assert( is_legal_nickname("a"));
-  test_assert(!is_legal_nickname(""));
-  test_assert(!is_legal_nickname("abcdefghijklmnopqrst")); /* 20 chars */
-  test_assert(!is_legal_nickname("hyphen-")); /* bad char */
-  test_assert( is_legal_nickname("abcdefghijklmnopqrs")); /* 19 chars */
-  test_assert(!is_legal_nickname("$AAAAAAAA01234AAAAAAAAAAAAAAAAAAAAAAAAAAA"));
+  tt_assert( is_legal_nickname("a"));
+  tt_assert(!is_legal_nickname(""));
+  tt_assert(!is_legal_nickname("abcdefghijklmnopqrst")); /* 20 chars */
+  tt_assert(!is_legal_nickname("hyphen-")); /* bad char */
+  tt_assert( is_legal_nickname("abcdefghijklmnopqrs")); /* 19 chars */
+  tt_assert(!is_legal_nickname("$AAAAAAAA01234AAAAAAAAAAAAAAAAAAAAAAAAAAA"));
   /* valid */
-  test_assert( is_legal_nickname_or_hexdigest(
+  tt_assert( is_legal_nickname_or_hexdigest(
                                  "$AAAAAAAA01234AAAAAAAAAAAAAAAAAAAAAAAAAAA"));
-  test_assert( is_legal_nickname_or_hexdigest(
+  tt_assert( is_legal_nickname_or_hexdigest(
                          "$AAAAAAAA01234AAAAAAAAAAAAAAAAAAAAAAAAAAA=fred"));
-  test_assert( is_legal_nickname_or_hexdigest(
+  tt_assert( is_legal_nickname_or_hexdigest(
                          "$AAAAAAAA01234AAAAAAAAAAAAAAAAAAAAAAAAAAA~fred"));
   /* too short */
-  test_assert(!is_legal_nickname_or_hexdigest(
+  tt_assert(!is_legal_nickname_or_hexdigest(
                                  "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"));
   /* illegal char */
-  test_assert(!is_legal_nickname_or_hexdigest(
+  tt_assert(!is_legal_nickname_or_hexdigest(
                                  "$AAAAAAzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"));
   /* hex part too long */
-  test_assert(!is_legal_nickname_or_hexdigest(
+  tt_assert(!is_legal_nickname_or_hexdigest(
                          "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"));
-  test_assert(!is_legal_nickname_or_hexdigest(
+  tt_assert(!is_legal_nickname_or_hexdigest(
                          "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=fred"));
   /* Bad nickname */
-  test_assert(!is_legal_nickname_or_hexdigest(
+  tt_assert(!is_legal_nickname_or_hexdigest(
                          "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="));
-  test_assert(!is_legal_nickname_or_hexdigest(
+  tt_assert(!is_legal_nickname_or_hexdigest(
                          "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA~"));
-  test_assert(!is_legal_nickname_or_hexdigest(
+  tt_assert(!is_legal_nickname_or_hexdigest(
                        "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA~hyphen-"));
-  test_assert(!is_legal_nickname_or_hexdigest(
+  tt_assert(!is_legal_nickname_or_hexdigest(
                        "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA~"
                        "abcdefghijklmnoppqrst"));
   /* Bad extra char. */
-  test_assert(!is_legal_nickname_or_hexdigest(
+  tt_assert(!is_legal_nickname_or_hexdigest(
                          "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA!"));
-  test_assert(is_legal_nickname_or_hexdigest("xyzzy"));
-  test_assert(is_legal_nickname_or_hexdigest("abcdefghijklmnopqrs"));
-  test_assert(!is_legal_nickname_or_hexdigest("abcdefghijklmnopqrst"));
+  tt_assert(is_legal_nickname_or_hexdigest("xyzzy"));
+  tt_assert(is_legal_nickname_or_hexdigest("abcdefghijklmnopqrs"));
+  tt_assert(!is_legal_nickname_or_hexdigest("abcdefghijklmnopqrst"));
  done:
   ;
 }
@@ -92,7 +92,7 @@ test_dir_formats(void)
   pk1 = pk_generate(0);
   pk2 = pk_generate(1);
 
-  test_assert(pk1 && pk2);
+  tt_assert(pk1 && pk2);
 
   hibernate_set_state_for_testing_(HIBERNATE_STATE_LIVE);
 
@@ -140,9 +140,9 @@ test_dir_formats(void)
   smartlist_add(r2->exit_policy, ex2);
   r2->nickname = tor_strdup("Fred");
 
-  test_assert(!crypto_pk_write_public_key_to_string(pk1, &pk1_str,
+  tt_assert(!crypto_pk_write_public_key_to_string(pk1, &pk1_str,
                                                     &pk1_str_len));
-  test_assert(!crypto_pk_write_public_key_to_string(pk2 , &pk2_str,
+  tt_assert(!crypto_pk_write_public_key_to_string(pk2 , &pk2_str,
                                                     &pk2_str_len));
 
   /* XXXX025 router_dump_to_string should really take this from ri.*/
@@ -150,7 +150,7 @@ test_dir_formats(void)
                                     "<magri@elsewhere.example.com>");
   buf = router_dump_router_to_string(r1, pk2);
   tor_free(options->ContactInfo);
-  test_assert(buf);
+  tt_assert(buf);
 
   strlcpy(buf2, "router Magri 192.168.0.1 9000 0 9003\n"
           "or-address [1:2:3:4::]:9999\n"
@@ -160,7 +160,7 @@ test_dir_formats(void)
           "protocols Link 1 2 Circuit 1\n"
           "published 1970-01-01 00:00:00\n"
           "fingerprint ", sizeof(buf2));
-  test_assert(!crypto_pk_get_fingerprint(pk2, fingerprint, 1));
+  tt_assert(!crypto_pk_get_fingerprint(pk2, fingerprint, 1));
   strlcat(buf2, fingerprint, sizeof(buf2));
   strlcat(buf2, "\nuptime 0\n"
   /* XXX the "0" above is hard-coded, but even if we made it reflect
@@ -178,22 +178,22 @@ test_dir_formats(void)
   buf[strlen(buf2)] = '\0'; /* Don't compare the sig; it's never the same
                              * twice */
 
-  test_streq(buf, buf2);
+  tt_str_op(buf,==, buf2);
   tor_free(buf);
 
   buf = router_dump_router_to_string(r1, pk2);
-  test_assert(buf);
+  tt_assert(buf);
   cp = buf;
   rp1 = router_parse_entry_from_string((const char*)cp,NULL,1,0,NULL);
-  test_assert(rp1);
-  test_eq(rp1->addr, r1->addr);
-  test_eq(rp1->or_port, r1->or_port);
+  tt_assert(rp1);
+  tt_int_op(rp1->addr,==, r1->addr);
+  tt_int_op(rp1->or_port,==, r1->or_port);
   //test_eq(rp1->dir_port, r1->dir_port);
-  test_eq(rp1->bandwidthrate, r1->bandwidthrate);
-  test_eq(rp1->bandwidthburst, r1->bandwidthburst);
-  test_eq(rp1->bandwidthcapacity, r1->bandwidthcapacity);
-  test_assert(crypto_pk_cmp_keys(rp1->onion_pkey, pk1) == 0);
-  test_assert(crypto_pk_cmp_keys(rp1->identity_pkey, pk2) == 0);
+  tt_int_op(rp1->bandwidthrate,==, r1->bandwidthrate);
+  tt_int_op(rp1->bandwidthburst,==, r1->bandwidthburst);
+  tt_int_op(rp1->bandwidthcapacity,==, r1->bandwidthcapacity);
+  tt_assert(crypto_pk_cmp_keys(rp1->onion_pkey, pk1) == 0);
+  tt_assert(crypto_pk_cmp_keys(rp1->identity_pkey, pk2) == 0);
   //test_assert(rp1->exit_policy == NULL);
   tor_free(buf);
 
@@ -205,7 +205,7 @@ test_dir_formats(void)
           "protocols Link 1 2 Circuit 1\n"
           "published 1970-01-01 00:00:05\n"
           "fingerprint ", sizeof(buf2));
-  test_assert(!crypto_pk_get_fingerprint(pk1, fingerprint, 1));
+  tt_assert(!crypto_pk_get_fingerprint(pk1, fingerprint, 1));
   strlcat(buf2, fingerprint, sizeof(buf2));
   strlcat(buf2, "\nuptime 0\n"
           "bandwidth 3000 3000 3000\n", sizeof(buf2));
@@ -224,42 +224,42 @@ test_dir_formats(void)
   buf = router_dump_router_to_string(r2, pk1);
   buf[strlen(buf2)] = '\0'; /* Don't compare the sig; it's never the same
                              * twice */
-  test_streq(buf, buf2);
+  tt_str_op(buf,==, buf2);
   tor_free(buf);
 
   buf = router_dump_router_to_string(r2, pk1);
   cp = buf;
   rp2 = router_parse_entry_from_string((const char*)cp,NULL,1,0,NULL);
-  test_assert(rp2);
-  test_eq(rp2->addr, r2->addr);
-  test_eq(rp2->or_port, r2->or_port);
-  test_eq(rp2->dir_port, r2->dir_port);
-  test_eq(rp2->bandwidthrate, r2->bandwidthrate);
-  test_eq(rp2->bandwidthburst, r2->bandwidthburst);
-  test_eq(rp2->bandwidthcapacity, r2->bandwidthcapacity);
+  tt_assert(rp2);
+  tt_int_op(rp2->addr,==, r2->addr);
+  tt_int_op(rp2->or_port,==, r2->or_port);
+  tt_int_op(rp2->dir_port,==, r2->dir_port);
+  tt_int_op(rp2->bandwidthrate,==, r2->bandwidthrate);
+  tt_int_op(rp2->bandwidthburst,==, r2->bandwidthburst);
+  tt_int_op(rp2->bandwidthcapacity,==, r2->bandwidthcapacity);
 #ifdef CURVE25519_ENABLED
-  test_memeq(rp2->onion_curve25519_pkey->public_key,
+  tt_mem_op(rp2->onion_curve25519_pkey->public_key,==,
              r2->onion_curve25519_pkey->public_key,
              CURVE25519_PUBKEY_LEN);
 #endif
-  test_assert(crypto_pk_cmp_keys(rp2->onion_pkey, pk2) == 0);
-  test_assert(crypto_pk_cmp_keys(rp2->identity_pkey, pk1) == 0);
+  tt_assert(crypto_pk_cmp_keys(rp2->onion_pkey, pk2) == 0);
+  tt_assert(crypto_pk_cmp_keys(rp2->identity_pkey, pk1) == 0);
 
-  test_eq(smartlist_len(rp2->exit_policy), 2);
+  tt_int_op(smartlist_len(rp2->exit_policy),==, 2);
 
   p = smartlist_get(rp2->exit_policy, 0);
-  test_eq(p->policy_type, ADDR_POLICY_ACCEPT);
-  test_assert(tor_addr_is_null(&p->addr));
-  test_eq(p->maskbits, 0);
-  test_eq(p->prt_min, 80);
-  test_eq(p->prt_max, 80);
+  tt_int_op(p->policy_type,==, ADDR_POLICY_ACCEPT);
+  tt_assert(tor_addr_is_null(&p->addr));
+  tt_int_op(p->maskbits,==, 0);
+  tt_int_op(p->prt_min,==, 80);
+  tt_int_op(p->prt_max,==, 80);
 
   p = smartlist_get(rp2->exit_policy, 1);
-  test_eq(p->policy_type, ADDR_POLICY_REJECT);
-  test_assert(tor_addr_eq(&p->addr, &ex2->addr));
-  test_eq(p->maskbits, 8);
-  test_eq(p->prt_min, 24);
-  test_eq(p->prt_max, 24);
+  tt_int_op(p->policy_type,==, ADDR_POLICY_REJECT);
+  tt_assert(tor_addr_eq(&p->addr, &ex2->addr));
+  tt_int_op(p->maskbits,==, 8);
+  tt_int_op(p->prt_min,==, 24);
+  tt_int_op(p->prt_max,==, 24);
 
 #if 0
   /* Okay, now for the directories. */
@@ -298,44 +298,44 @@ test_dir_versions(void)
   tor_version_t ver1;
 
   /* Try out version parsing functionality */
-  test_eq(0, tor_version_parse("0.3.4pre2-cvs", &ver1));
-  test_eq(0, ver1.major);
-  test_eq(3, ver1.minor);
-  test_eq(4, ver1.micro);
-  test_eq(VER_PRE, ver1.status);
-  test_eq(2, ver1.patchlevel);
-  test_eq(0, tor_version_parse("0.3.4rc1", &ver1));
-  test_eq(0, ver1.major);
-  test_eq(3, ver1.minor);
-  test_eq(4, ver1.micro);
-  test_eq(VER_RC, ver1.status);
-  test_eq(1, ver1.patchlevel);
-  test_eq(0, tor_version_parse("1.3.4", &ver1));
-  test_eq(1, ver1.major);
-  test_eq(3, ver1.minor);
-  test_eq(4, ver1.micro);
-  test_eq(VER_RELEASE, ver1.status);
-  test_eq(0, ver1.patchlevel);
-  test_eq(0, tor_version_parse("1.3.4.999", &ver1));
-  test_eq(1, ver1.major);
-  test_eq(3, ver1.minor);
-  test_eq(4, ver1.micro);
-  test_eq(VER_RELEASE, ver1.status);
-  test_eq(999, ver1.patchlevel);
-  test_eq(0, tor_version_parse("0.1.2.4-alpha", &ver1));
-  test_eq(0, ver1.major);
-  test_eq(1, ver1.minor);
-  test_eq(2, ver1.micro);
-  test_eq(4, ver1.patchlevel);
-  test_eq(VER_RELEASE, ver1.status);
-  test_streq("alpha", ver1.status_tag);
-  test_eq(0, tor_version_parse("0.1.2.4", &ver1));
-  test_eq(0, ver1.major);
-  test_eq(1, ver1.minor);
-  test_eq(2, ver1.micro);
-  test_eq(4, ver1.patchlevel);
-  test_eq(VER_RELEASE, ver1.status);
-  test_streq("", ver1.status_tag);
+  tt_int_op(0,==, tor_version_parse("0.3.4pre2-cvs", &ver1));
+  tt_int_op(0,==, ver1.major);
+  tt_int_op(3,==, ver1.minor);
+  tt_int_op(4,==, ver1.micro);
+  tt_int_op(VER_PRE,==, ver1.status);
+  tt_int_op(2,==, ver1.patchlevel);
+  tt_int_op(0,==, tor_version_parse("0.3.4rc1", &ver1));
+  tt_int_op(0,==, ver1.major);
+  tt_int_op(3,==, ver1.minor);
+  tt_int_op(4,==, ver1.micro);
+  tt_int_op(VER_RC,==, ver1.status);
+  tt_int_op(1,==, ver1.patchlevel);
+  tt_int_op(0,==, tor_version_parse("1.3.4", &ver1));
+  tt_int_op(1,==, ver1.major);
+  tt_int_op(3,==, ver1.minor);
+  tt_int_op(4,==, ver1.micro);
+  tt_int_op(VER_RELEASE,==, ver1.status);
+  tt_int_op(0,==, ver1.patchlevel);
+  tt_int_op(0,==, tor_version_parse("1.3.4.999", &ver1));
+  tt_int_op(1,==, ver1.major);
+  tt_int_op(3,==, ver1.minor);
+  tt_int_op(4,==, ver1.micro);
+  tt_int_op(VER_RELEASE,==, ver1.status);
+  tt_int_op(999,==, ver1.patchlevel);
+  tt_int_op(0,==, tor_version_parse("0.1.2.4-alpha", &ver1));
+  tt_int_op(0,==, ver1.major);
+  tt_int_op(1,==, ver1.minor);
+  tt_int_op(2,==, ver1.micro);
+  tt_int_op(4,==, ver1.patchlevel);
+  tt_int_op(VER_RELEASE,==, ver1.status);
+  tt_str_op("alpha",==, ver1.status_tag);
+  tt_int_op(0,==, tor_version_parse("0.1.2.4", &ver1));
+  tt_int_op(0,==, ver1.major);
+  tt_int_op(1,==, ver1.minor);
+  tt_int_op(2,==, ver1.micro);
+  tt_int_op(4,==, ver1.patchlevel);
+  tt_int_op(VER_RELEASE,==, ver1.status);
+  tt_str_op("",==, ver1.status_tag);
 
 #define tt_versionstatus_op(vs1, op, vs2)                               \
   tt_assert_test_type(vs1,vs2,#vs1" "#op" "#vs2,version_status_t,       \
@@ -368,42 +368,42 @@ test_dir_versions(void)
   /* On list, not newer than any on same series. */
   test_v_i_o(VS_UNRECOMMENDED,
              "0.1.0.1", "Tor 0.1.0.2,Tor 0.0.9.5,Tor 0.1.1.0");
-  test_eq(0, tor_version_as_new_as("Tor 0.0.5", "0.0.9pre1-cvs"));
-  test_eq(1, tor_version_as_new_as(
+  tt_int_op(0,==, tor_version_as_new_as("Tor 0.0.5", "0.0.9pre1-cvs"));
+  tt_int_op(1,==, tor_version_as_new_as(
           "Tor 0.0.8 on Darwin 64-121-192-100.c3-0."
           "sfpo-ubr1.sfrn-sfpo.ca.cable.rcn.com Power Macintosh",
           "0.0.8rc2"));
-  test_eq(0, tor_version_as_new_as(
+  tt_int_op(0,==, tor_version_as_new_as(
           "Tor 0.0.8 on Darwin 64-121-192-100.c3-0."
           "sfpo-ubr1.sfrn-sfpo.ca.cable.rcn.com Power Macintosh", "0.0.8.2"));
 
   /* Now try svn revisions. */
-  test_eq(1, tor_version_as_new_as("Tor 0.2.1.0-dev (r100)",
+  tt_int_op(1,==, tor_version_as_new_as("Tor 0.2.1.0-dev (r100)",
                                    "Tor 0.2.1.0-dev (r99)"));
-  test_eq(1, tor_version_as_new_as("Tor 0.2.1.0-dev (r100) on Banana Jr",
+  tt_int_op(1,==, tor_version_as_new_as("Tor 0.2.1.0-dev (r100) on Banana Jr",
                                    "Tor 0.2.1.0-dev (r99) on Hal 9000"));
-  test_eq(1, tor_version_as_new_as("Tor 0.2.1.0-dev (r100)",
+  tt_int_op(1,==, tor_version_as_new_as("Tor 0.2.1.0-dev (r100)",
                                    "Tor 0.2.1.0-dev on Colossus"));
-  test_eq(0, tor_version_as_new_as("Tor 0.2.1.0-dev (r99)",
+  tt_int_op(0,==, tor_version_as_new_as("Tor 0.2.1.0-dev (r99)",
                                    "Tor 0.2.1.0-dev (r100)"));
-  test_eq(0, tor_version_as_new_as("Tor 0.2.1.0-dev (r99) on MCP",
+  tt_int_op(0,==, tor_version_as_new_as("Tor 0.2.1.0-dev (r99) on MCP",
                                    "Tor 0.2.1.0-dev (r100) on AM"));
-  test_eq(0, tor_version_as_new_as("Tor 0.2.1.0-dev",
+  tt_int_op(0,==, tor_version_as_new_as("Tor 0.2.1.0-dev",
                                    "Tor 0.2.1.0-dev (r99)"));
-  test_eq(1, tor_version_as_new_as("Tor 0.2.1.1",
+  tt_int_op(1,==, tor_version_as_new_as("Tor 0.2.1.1",
                                    "Tor 0.2.1.0-dev (r99)"));
 
   /* Now try git revisions */
-  test_eq(0, tor_version_parse("0.5.6.7 (git-ff00ff)", &ver1));
-  test_eq(0, ver1.major);
-  test_eq(5, ver1.minor);
-  test_eq(6, ver1.micro);
-  test_eq(7, ver1.patchlevel);
-  test_eq(3, ver1.git_tag_len);
-  test_memeq(ver1.git_tag, "\xff\x00\xff", 3);
-  test_eq(-1, tor_version_parse("0.5.6.7 (git-ff00xx)", &ver1));
-  test_eq(-1, tor_version_parse("0.5.6.7 (git-ff00fff)", &ver1));
-  test_eq(0, tor_version_parse("0.5.6.7 (git ff00fff)", &ver1));
+  tt_int_op(0,==, tor_version_parse("0.5.6.7 (git-ff00ff)", &ver1));
+  tt_int_op(0,==, ver1.major);
+  tt_int_op(5,==, ver1.minor);
+  tt_int_op(6,==, ver1.micro);
+  tt_int_op(7,==, ver1.patchlevel);
+  tt_int_op(3,==, ver1.git_tag_len);
+  tt_mem_op(ver1.git_tag,==, "\xff\x00\xff", 3);
+  tt_int_op(-1,==, tor_version_parse("0.5.6.7 (git-ff00xx)", &ver1));
+  tt_int_op(-1,==, tor_version_parse("0.5.6.7 (git-ff00fff)", &ver1));
+  tt_int_op(0,==, tor_version_parse("0.5.6.7 (git ff00fff)", &ver1));
  done:
   ;
 }
@@ -424,13 +424,13 @@ test_dir_fp_pairs(void)
        "48657861646563696d616c2069736e277420736f-"
        "676f6f6420666f7220686964696e6720796f7572.z", sl);
 
-  test_eq(smartlist_len(sl), 2);
+  tt_int_op(smartlist_len(sl),==, 2);
   pair = smartlist_get(sl, 0);
-  test_memeq(pair->first,  "Hexadecimal isn't so", DIGEST_LEN);
-  test_memeq(pair->second, "good for hiding your", DIGEST_LEN);
+  tt_mem_op(pair->first,==,  "Hexadecimal isn't so", DIGEST_LEN);
+  tt_mem_op(pair->second,==, "good for hiding your", DIGEST_LEN);
   pair = smartlist_get(sl, 1);
-  test_memeq(pair->first,  "secret data.\0\0\0\0\0\xff\xff\xff", DIGEST_LEN);
-  test_memeq(pair->second, "Use AES-256 instead.", DIGEST_LEN);
+  tt_mem_op(pair->first,==,  "secret data.\0\0\0\0\0\xff\xff\xff", DIGEST_LEN);
+  tt_mem_op(pair->second,==, "Use AES-256 instead.", DIGEST_LEN);
 
  done:
   SMARTLIST_FOREACH(sl, fp_pair_t *, pair, tor_free(pair));
@@ -607,14 +607,14 @@ test_dir_measured_bw_kb(void)
 
   for (i = 0; strcmp(lines_fail[i], "end"); i++) {
     //fprintf(stderr, "Testing: %s\n", lines_fail[i]);
-    test_assert(measured_bw_line_parse(&mbwl, lines_fail[i]) == -1);
+    tt_assert(measured_bw_line_parse(&mbwl, lines_fail[i]) == -1);
   }
 
   for (i = 0; strcmp(lines_pass[i], "end"); i++) {
     //fprintf(stderr, "Testing: %s %d\n", lines_pass[i], TOR_ISSPACE('\n'));
-    test_assert(measured_bw_line_parse(&mbwl, lines_pass[i]) == 0);
-    test_assert(mbwl.bw_kb == 1024);
-    test_assert(strcmp(mbwl.node_hex,
+    tt_assert(measured_bw_line_parse(&mbwl, lines_pass[i]) == 0);
+    tt_assert(mbwl.bw_kb == 1024);
+    tt_assert(strcmp(mbwl.node_hex,
                 "557365204145532d32353620696e73746561642e") == 0);
   }
 
@@ -638,7 +638,7 @@ test_dir_measured_bw_kb_cache(void)
 
   /* First, clear the cache and assert that it's empty */
   dirserv_clear_measured_bw_cache();
-  test_eq(dirserv_get_measured_bw_cache_size(), 0);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 0);
   /*
    * Set up test mbwls; none of the dirserv_cache_*() functions care about
    * the node_hex field.
@@ -651,49 +651,49 @@ test_dir_measured_bw_kb_cache(void)
   mbwl[2].bw_kb = 80;
   /* Try caching something */
   dirserv_cache_measured_bw(&(mbwl[0]), curr);
-  test_eq(dirserv_get_measured_bw_cache_size(), 1);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 1);
   /* Okay, let's see if we can retrieve it */
-  test_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,&bw, &as_of));
-  test_eq(bw, 20);
-  test_eq(as_of, MBWC_INIT_TIME);
+  tt_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,&bw, &as_of));
+  tt_int_op(bw,==, 20);
+  tt_int_op(as_of,==, MBWC_INIT_TIME);
   /* Try retrieving it without some outputs */
-  test_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,NULL, NULL));
-  test_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,&bw, NULL));
-  test_eq(bw, 20);
-  test_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,NULL,&as_of));
-  test_eq(as_of, MBWC_INIT_TIME);
+  tt_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,NULL, NULL));
+  tt_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,&bw, NULL));
+  tt_int_op(bw,==, 20);
+  tt_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,NULL,&as_of));
+  tt_int_op(as_of,==, MBWC_INIT_TIME);
   /* Now expire it */
   curr += MAX_MEASUREMENT_AGE + 1;
   dirserv_expire_measured_bw_cache(curr);
   /* Check that the cache is empty */
-  test_eq(dirserv_get_measured_bw_cache_size(), 0);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 0);
   /* Check that we can't retrieve it */
-  test_assert(!dirserv_query_measured_bw_cache_kb(mbwl[0].node_id, NULL,NULL));
+  tt_assert(!dirserv_query_measured_bw_cache_kb(mbwl[0].node_id, NULL,NULL));
   /* Try caching a few things now */
   dirserv_cache_measured_bw(&(mbwl[0]), curr);
-  test_eq(dirserv_get_measured_bw_cache_size(), 1);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 1);
   curr += MAX_MEASUREMENT_AGE / 4;
   dirserv_cache_measured_bw(&(mbwl[1]), curr);
-  test_eq(dirserv_get_measured_bw_cache_size(), 2);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 2);
   curr += MAX_MEASUREMENT_AGE / 4;
   dirserv_cache_measured_bw(&(mbwl[2]), curr);
-  test_eq(dirserv_get_measured_bw_cache_size(), 3);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 3);
   curr += MAX_MEASUREMENT_AGE / 4 + 1;
   /* Do an expire that's too soon to get any of them */
   dirserv_expire_measured_bw_cache(curr);
-  test_eq(dirserv_get_measured_bw_cache_size(), 3);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 3);
   /* Push the oldest one off the cliff */
   curr += MAX_MEASUREMENT_AGE / 4;
   dirserv_expire_measured_bw_cache(curr);
-  test_eq(dirserv_get_measured_bw_cache_size(), 2);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 2);
   /* And another... */
   curr += MAX_MEASUREMENT_AGE / 4;
   dirserv_expire_measured_bw_cache(curr);
-  test_eq(dirserv_get_measured_bw_cache_size(), 1);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 1);
   /* This should empty it out again */
   curr += MAX_MEASUREMENT_AGE / 4;
   dirserv_expire_measured_bw_cache(curr);
-  test_eq(dirserv_get_measured_bw_cache_size(), 0);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 0);
 
  done:
   return;
@@ -725,11 +725,11 @@ test_dir_param_voting(void)
                          "abcd=20 c=60 cw=500 x-yz=-9 zzzzz=101", NULL, 0, 0);
   smartlist_split_string(vote4.net_params,
                          "ab=900 abcd=200 c=1 cw=51 x-yz=100", NULL, 0, 0);
-  test_eq(100, networkstatus_get_param(&vote4, "x-yz", 50, 0, 300));
-  test_eq(222, networkstatus_get_param(&vote4, "foobar", 222, 0, 300));
-  test_eq(80, networkstatus_get_param(&vote4, "ab", 12, 0, 80));
-  test_eq(-8, networkstatus_get_param(&vote4, "ab", -12, -100, -8));
-  test_eq(0, networkstatus_get_param(&vote4, "foobar", 0, -100, 8));
+  tt_int_op(100,==, networkstatus_get_param(&vote4, "x-yz", 50, 0, 300));
+  tt_int_op(222,==, networkstatus_get_param(&vote4, "foobar", 222, 0, 300));
+  tt_int_op(80,==, networkstatus_get_param(&vote4, "ab", 12, 0, 80));
+  tt_int_op(-8,==, networkstatus_get_param(&vote4, "ab", -12, -100, -8));
+  tt_int_op(0,==, networkstatus_get_param(&vote4, "foobar", 0, -100, 8));
 
   smartlist_add(votes, &vote1);
 
@@ -737,59 +737,59 @@ test_dir_param_voting(void)
    * networks without many dirauths. */
 
   res = dirvote_compute_params(votes, 12, 2);
-  test_streq(res, "");
+  tt_str_op(res,==, "");
   tor_free(res);
 
   res = dirvote_compute_params(votes, 12, 1);
-  test_streq(res, "ab=90 abcd=20 cw=50 x-yz=-99");
+  tt_str_op(res,==, "ab=90 abcd=20 cw=50 x-yz=-99");
   tor_free(res);
 
   smartlist_add(votes, &vote2);
 
   res = dirvote_compute_params(votes, 12, 2);
-  test_streq(res, "ab=27 cw=5 x-yz=-99");
+  tt_str_op(res,==, "ab=27 cw=5 x-yz=-99");
   tor_free(res);
 
   res = dirvote_compute_params(votes, 12, 3);
-  test_streq(res, "ab=27 cw=5 x-yz=-99");
+  tt_str_op(res,==, "ab=27 cw=5 x-yz=-99");
   tor_free(res);
 
   res = dirvote_compute_params(votes, 12, 6);
-  test_streq(res, "");
+  tt_str_op(res,==, "");
   tor_free(res);
 
   smartlist_add(votes, &vote3);
 
   res = dirvote_compute_params(votes, 12, 3);
-  test_streq(res, "ab=27 abcd=20 cw=50 x-yz=-9");
+  tt_str_op(res,==, "ab=27 abcd=20 cw=50 x-yz=-9");
   tor_free(res);
 
   res = dirvote_compute_params(votes, 12, 5);
-  test_streq(res, "cw=50 x-yz=-9");
+  tt_str_op(res,==, "cw=50 x-yz=-9");
   tor_free(res);
 
   res = dirvote_compute_params(votes, 12, 9);
-  test_streq(res, "cw=50 x-yz=-9");
+  tt_str_op(res,==, "cw=50 x-yz=-9");
   tor_free(res);
 
   smartlist_add(votes, &vote4);
 
   res = dirvote_compute_params(votes, 12, 4);
-  test_streq(res, "ab=90 abcd=20 cw=50 x-yz=-9");
+  tt_str_op(res,==, "ab=90 abcd=20 cw=50 x-yz=-9");
   tor_free(res);
 
   res = dirvote_compute_params(votes, 12, 5);
-  test_streq(res, "ab=90 abcd=20 cw=50 x-yz=-9");
+  tt_str_op(res,==, "ab=90 abcd=20 cw=50 x-yz=-9");
   tor_free(res);
 
   /* Test that the special-cased "at least three dirauths voted for
    * this param" logic works as expected. */
   res = dirvote_compute_params(votes, 12, 6);
-  test_streq(res, "ab=90 abcd=20 cw=50 x-yz=-9");
+  tt_str_op(res,==, "ab=90 abcd=20 cw=50 x-yz=-9");
   tor_free(res);
 
   res = dirvote_compute_params(votes, 12, 10);
-  test_streq(res, "ab=90 abcd=20 cw=50 x-yz=-9");
+  tt_str_op(res,==, "ab=90 abcd=20 cw=50 x-yz=-9");
   tor_free(res);
 
  done:
@@ -821,14 +821,14 @@ static void
 test_same_voter(networkstatus_voter_info_t *v1,
                 networkstatus_voter_info_t *v2)
 {
-  test_streq(v1->nickname, v2->nickname);
-  test_memeq(v1->identity_digest, v2->identity_digest, DIGEST_LEN);
-  test_streq(v1->address, v2->address);
-  test_eq(v1->addr, v2->addr);
-  test_eq(v1->dir_port, v2->dir_port);
-  test_eq(v1->or_port, v2->or_port);
-  test_streq(v1->contact, v2->contact);
-  test_memeq(v1->vote_digest, v2->vote_digest, DIGEST_LEN);
+  tt_str_op(v1->nickname,==, v2->nickname);
+  tt_mem_op(v1->identity_digest,==, v2->identity_digest, DIGEST_LEN);
+  tt_str_op(v1->address,==, v2->address);
+  tt_int_op(v1->addr,==, v2->addr);
+  tt_int_op(v1->dir_port,==, v2->dir_port);
+  tt_int_op(v1->or_port,==, v2->or_port);
+  tt_str_op(v1->contact,==, v2->contact);
+  tt_mem_op(v1->vote_digest,==, v2->vote_digest, DIGEST_LEN);
  done:
   ;
 }
@@ -965,7 +965,7 @@ gen_routerstatus_for_v3ns(int idx, time_t now)
       break;
     default:
       /* Shouldn't happen */
-      test_assert(0);
+      tt_assert(0);
   }
   if (vrs) {
     vrs->microdesc = tor_malloc_zero(sizeof(vote_microdesc_hash_t));
@@ -986,14 +986,14 @@ vote_tweaks_for_v3ns(networkstatus_t *v, int voter, time_t now)
   vote_routerstatus_t *vrs;
   const char *msg = NULL;
 
-  test_assert(v);
+  tt_assert(v);
   (void)now;
 
   if (voter == 1) {
     measured_bw_line_t mbw;
     memset(mbw.node_id, 33, sizeof(mbw.node_id));
     mbw.bw_kb = 1024;
-    test_assert(measured_bw_line_apply(&mbw,
+    tt_assert(measured_bw_line_apply(&mbw,
                 v->routerstatus_list) == 1);
   } else if (voter == 2 || voter == 3) {
     /* Monkey around with the list a bit */
@@ -1009,7 +1009,7 @@ vote_tweaks_for_v3ns(networkstatus_t *v, int voter, time_t now)
       vote_routerstatus_free(vrs);
       vrs = smartlist_get(v->routerstatus_list, 0);
       memset(vrs->status.descriptor_digest, (int)'Z', DIGEST_LEN);
-      test_assert(router_add_to_routerlist(
+      tt_assert(router_add_to_routerlist(
                   generate_ri_from_rs(vrs), &msg,0,0) >= 0);
     }
   }
@@ -1027,9 +1027,9 @@ test_vrs_for_v3ns(vote_routerstatus_t *vrs, int voter, time_t now)
   routerstatus_t *rs;
   tor_addr_t addr_ipv6;
 
-  test_assert(vrs);
+  tt_assert(vrs);
   rs = &(vrs->status);
-  test_assert(rs);
+  tt_assert(rs);
 
   /* Split out by digests to test */
   if (tor_memeq(rs->identity_digest,
@@ -1038,17 +1038,17 @@ test_vrs_for_v3ns(vote_routerstatus_t *vrs, int voter, time_t now)
                 DIGEST_LEN) &&
                 (voter == 1)) {
     /* Check the first routerstatus. */
-    test_streq(vrs->version, "0.1.2.14");
-    test_eq(rs->published_on, now-1500);
-    test_streq(rs->nickname, "router2");
-    test_memeq(rs->identity_digest,
+    tt_str_op(vrs->version,==, "0.1.2.14");
+    tt_int_op(rs->published_on,==, now-1500);
+    tt_str_op(rs->nickname,==, "router2");
+    tt_mem_op(rs->identity_digest,==,
                "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3"
                "\x3\x3\x3\x3",
                DIGEST_LEN);
-    test_memeq(rs->descriptor_digest, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN);
-    test_eq(rs->addr, 0x99008801);
-    test_eq(rs->or_port, 443);
-    test_eq(rs->dir_port, 8000);
+    tt_mem_op(rs->descriptor_digest,==, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN);
+    tt_int_op(rs->addr,==, 0x99008801);
+    tt_int_op(rs->or_port,==, 443);
+    tt_int_op(rs->dir_port,==, 8000);
     /* no flags except "running" (16) and "v2dir" (64) */
     tt_u64_op(vrs->flags, ==, U64_LITERAL(80));
   } else if (tor_memeq(rs->identity_digest,
@@ -1056,24 +1056,24 @@ test_vrs_for_v3ns(vote_routerstatus_t *vrs, int voter, time_t now)
                        "\x5\x5\x5\x5",
                        DIGEST_LEN) &&
                        (voter == 1 || voter == 2)) {
-    test_memeq(rs->identity_digest,
+    tt_mem_op(rs->identity_digest,==,
                "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5"
                "\x5\x5\x5\x5",
                DIGEST_LEN);
 
     if (voter == 1) {
       /* Check the second routerstatus. */
-      test_streq(vrs->version, "0.2.0.5");
-      test_eq(rs->published_on, now-1000);
-      test_streq(rs->nickname, "router1");
+      tt_str_op(vrs->version,==, "0.2.0.5");
+      tt_int_op(rs->published_on,==, now-1000);
+      tt_str_op(rs->nickname,==, "router1");
     }
-    test_memeq(rs->descriptor_digest, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN);
-    test_eq(rs->addr, 0x99009901);
-    test_eq(rs->or_port, 443);
-    test_eq(rs->dir_port, 0);
+    tt_mem_op(rs->descriptor_digest,==, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN);
+    tt_int_op(rs->addr,==, 0x99009901);
+    tt_int_op(rs->or_port,==, 443);
+    tt_int_op(rs->dir_port,==, 0);
     tor_addr_parse(&addr_ipv6, "[1:2:3::4]");
-    test_assert(tor_addr_eq(&rs->ipv6_addr, &addr_ipv6));
-    test_eq(rs->ipv6_orport, 4711);
+    tt_assert(tor_addr_eq(&rs->ipv6_addr, &addr_ipv6));
+    tt_int_op(rs->ipv6_orport,==, 4711);
     if (voter == 1) {
       /* all except "authority" (1) and "v2dir" (64) */
       tt_u64_op(vrs->flags, ==, U64_LITERAL(190));
@@ -1087,7 +1087,7 @@ test_vrs_for_v3ns(vote_routerstatus_t *vrs, int voter, time_t now)
                        DIGEST_LEN) &&
                        (voter == 1 || voter == 2)) {
     /* Check the measured bandwidth bits */
-    test_assert(vrs->has_measured_bw &&
+    tt_assert(vrs->has_measured_bw &&
                 vrs->measured_bw_kb == 1024);
   } else {
     /*
@@ -1109,9 +1109,9 @@ test_consensus_for_v3ns(networkstatus_t *con, time_t now)
 {
   (void)now;
 
-  test_assert(con);
-  test_assert(!con->cert);
-  test_eq(2, smartlist_len(con->routerstatus_list));
+  tt_assert(con);
+  tt_assert(!con->cert);
+  tt_int_op(2,==, smartlist_len(con->routerstatus_list));
   /* There should be two listed routers: one with identity 3, one with
    * identity 5. */
 
@@ -1127,7 +1127,7 @@ test_routerstatus_for_v3ns(routerstatus_t *rs, time_t now)
 {
   tor_addr_t addr_ipv6;
 
-  test_assert(rs);
+  tt_assert(rs);
 
   /* There should be two listed routers: one with identity 3, one with
    * identity 5. */
@@ -1136,49 +1136,49 @@ test_routerstatus_for_v3ns(routerstatus_t *rs, time_t now)
                 "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3"
                 "\x3\x3",
                 DIGEST_LEN)) {
-    test_memeq(rs->identity_digest,
+    tt_mem_op(rs->identity_digest,==,
                "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3",
                DIGEST_LEN);
-    test_memeq(rs->descriptor_digest, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN);
-    test_assert(!rs->is_authority);
-    test_assert(!rs->is_exit);
-    test_assert(!rs->is_fast);
-    test_assert(!rs->is_possible_guard);
-    test_assert(!rs->is_stable);
+    tt_mem_op(rs->descriptor_digest,==, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN);
+    tt_assert(!rs->is_authority);
+    tt_assert(!rs->is_exit);
+    tt_assert(!rs->is_fast);
+    tt_assert(!rs->is_possible_guard);
+    tt_assert(!rs->is_stable);
     /* (If it wasn't running it wouldn't be here) */
-    test_assert(rs->is_flagged_running);
-    test_assert(!rs->is_valid);
-    test_assert(!rs->is_named);
+    tt_assert(rs->is_flagged_running);
+    tt_assert(!rs->is_valid);
+    tt_assert(!rs->is_named);
     /* XXXX check version */
   } else if (tor_memeq(rs->identity_digest,
                        "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5"
                        "\x5\x5\x5\x5",
                        DIGEST_LEN)) {
     /* This one showed up in 3 digests. Twice with ID 'M', once with 'Z'.  */
-    test_memeq(rs->identity_digest,
+    tt_mem_op(rs->identity_digest,==,
                "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5",
                DIGEST_LEN);
-    test_streq(rs->nickname, "router1");
-    test_memeq(rs->descriptor_digest, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN);
-    test_eq(rs->published_on, now-1000);
-    test_eq(rs->addr, 0x99009901);
-    test_eq(rs->or_port, 443);
-    test_eq(rs->dir_port, 0);
+    tt_str_op(rs->nickname,==, "router1");
+    tt_mem_op(rs->descriptor_digest,==, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN);
+    tt_int_op(rs->published_on,==, now-1000);
+    tt_int_op(rs->addr,==, 0x99009901);
+    tt_int_op(rs->or_port,==, 443);
+    tt_int_op(rs->dir_port,==, 0);
     tor_addr_parse(&addr_ipv6, "[1:2:3::4]");
-    test_assert(tor_addr_eq(&rs->ipv6_addr, &addr_ipv6));
-    test_eq(rs->ipv6_orport, 4711);
-    test_assert(!rs->is_authority);
-    test_assert(rs->is_exit);
-    test_assert(rs->is_fast);
-    test_assert(rs->is_possible_guard);
-    test_assert(rs->is_stable);
-    test_assert(rs->is_flagged_running);
-    test_assert(rs->is_valid);
-    test_assert(!rs->is_named);
+    tt_assert(tor_addr_eq(&rs->ipv6_addr, &addr_ipv6));
+    tt_int_op(rs->ipv6_orport,==, 4711);
+    tt_assert(!rs->is_authority);
+    tt_assert(rs->is_exit);
+    tt_assert(rs->is_fast);
+    tt_assert(rs->is_possible_guard);
+    tt_assert(rs->is_stable);
+    tt_assert(rs->is_flagged_running);
+    tt_assert(rs->is_valid);
+    tt_assert(!rs->is_named);
     /* XXXX check version */
   } else {
     /* Weren't expecting this... */
-    test_assert(0);
+    tt_assert(0);
   }
 
  done:
@@ -1226,31 +1226,31 @@ test_a_networkstatus(
   networkstatus_t *con2=NULL, *con_md2=NULL, *con3=NULL, *con_md3=NULL;
   ns_detached_signatures_t *dsig1=NULL, *dsig2=NULL;
 
-  test_assert(vrs_gen);
-  test_assert(rs_test);
-  test_assert(vrs_test);
+  tt_assert(vrs_gen);
+  tt_assert(rs_test);
+  tt_assert(vrs_test);
 
   /* Parse certificates and keys. */
   cert1 = authority_cert_parse_from_string(AUTHORITY_CERT_1, NULL);
-  test_assert(cert1);
+  tt_assert(cert1);
   cert2 = authority_cert_parse_from_string(AUTHORITY_CERT_2, NULL);
-  test_assert(cert2);
+  tt_assert(cert2);
   cert3 = authority_cert_parse_from_string(AUTHORITY_CERT_3, NULL);
-  test_assert(cert3);
+  tt_assert(cert3);
   sign_skey_1 = crypto_pk_new();
   sign_skey_2 = crypto_pk_new();
   sign_skey_3 = crypto_pk_new();
   sign_skey_leg1 = pk_generate(4);
 
-  test_assert(!crypto_pk_read_private_key_from_string(sign_skey_1,
+  tt_assert(!crypto_pk_read_private_key_from_string(sign_skey_1,
                                                    AUTHORITY_SIGNKEY_1, -1));
-  test_assert(!crypto_pk_read_private_key_from_string(sign_skey_2,
+  tt_assert(!crypto_pk_read_private_key_from_string(sign_skey_2,
                                                    AUTHORITY_SIGNKEY_2, -1));
-  test_assert(!crypto_pk_read_private_key_from_string(sign_skey_3,
+  tt_assert(!crypto_pk_read_private_key_from_string(sign_skey_3,
                                                    AUTHORITY_SIGNKEY_3, -1));
 
-  test_assert(!crypto_pk_cmp_keys(sign_skey_1, cert1->signing_key));
-  test_assert(!crypto_pk_cmp_keys(sign_skey_2, cert2->signing_key));
+  tt_assert(!crypto_pk_cmp_keys(sign_skey_1, cert1->signing_key));
+  tt_assert(!crypto_pk_cmp_keys(sign_skey_2, cert2->signing_key));
 
   /*
    * Set up a vote; generate it; try to parse it.
@@ -1292,7 +1292,7 @@ test_a_networkstatus(
     vrs = vrs_gen(idx, now);
     if (vrs) {
       smartlist_add(vote->routerstatus_list, vrs);
-      test_assert(router_add_to_routerlist(generate_ri_from_rs(vrs),
+      tt_assert(router_add_to_routerlist(generate_ri_from_rs(vrs),
                                            &msg,0,0)>=0);
       ++idx;
     }
@@ -1301,41 +1301,41 @@ test_a_networkstatus(
 
   /* dump the vote and try to parse it. */
   v1_text = format_networkstatus_vote(sign_skey_1, vote);
-  test_assert(v1_text);
+  tt_assert(v1_text);
   v1 = networkstatus_parse_vote_from_string(v1_text, NULL, NS_TYPE_VOTE);
-  test_assert(v1);
+  tt_assert(v1);
 
   /* Make sure the parsed thing was right. */
-  test_eq(v1->type, NS_TYPE_VOTE);
-  test_eq(v1->published, vote->published);
-  test_eq(v1->valid_after, vote->valid_after);
-  test_eq(v1->fresh_until, vote->fresh_until);
-  test_eq(v1->valid_until, vote->valid_until);
-  test_eq(v1->vote_seconds, vote->vote_seconds);
-  test_eq(v1->dist_seconds, vote->dist_seconds);
-  test_streq(v1->client_versions, vote->client_versions);
-  test_streq(v1->server_versions, vote->server_versions);
-  test_assert(v1->voters && smartlist_len(v1->voters));
+  tt_int_op(v1->type,==, NS_TYPE_VOTE);
+  tt_int_op(v1->published,==, vote->published);
+  tt_int_op(v1->valid_after,==, vote->valid_after);
+  tt_int_op(v1->fresh_until,==, vote->fresh_until);
+  tt_int_op(v1->valid_until,==, vote->valid_until);
+  tt_int_op(v1->vote_seconds,==, vote->vote_seconds);
+  tt_int_op(v1->dist_seconds,==, vote->dist_seconds);
+  tt_str_op(v1->client_versions,==, vote->client_versions);
+  tt_str_op(v1->server_versions,==, vote->server_versions);
+  tt_assert(v1->voters && smartlist_len(v1->voters));
   voter = smartlist_get(v1->voters, 0);
-  test_streq(voter->nickname, "Voter1");
-  test_streq(voter->address, "1.2.3.4");
-  test_eq(voter->addr, 0x01020304);
-  test_eq(voter->dir_port, 80);
-  test_eq(voter->or_port, 9000);
-  test_streq(voter->contact, "voter@example.com");
-  test_assert(v1->cert);
-  test_assert(!crypto_pk_cmp_keys(sign_skey_1, v1->cert->signing_key));
+  tt_str_op(voter->nickname,==, "Voter1");
+  tt_str_op(voter->address,==, "1.2.3.4");
+  tt_int_op(voter->addr,==, 0x01020304);
+  tt_int_op(voter->dir_port,==, 80);
+  tt_int_op(voter->or_port,==, 9000);
+  tt_str_op(voter->contact,==, "voter@example.com");
+  tt_assert(v1->cert);
+  tt_assert(!crypto_pk_cmp_keys(sign_skey_1, v1->cert->signing_key));
   cp = smartlist_join_strings(v1->known_flags, ":", 0, NULL);
-  test_streq(cp, "Authority:Exit:Fast:Guard:Running:Stable:V2Dir:Valid");
+  tt_str_op(cp,==, "Authority:Exit:Fast:Guard:Running:Stable:V2Dir:Valid");
   tor_free(cp);
-  test_eq(smartlist_len(v1->routerstatus_list), n_vrs);
+  tt_int_op(smartlist_len(v1->routerstatus_list),==, n_vrs);
 
   if (vote_tweaks) params_tweaked += vote_tweaks(v1, 1, now);
 
   /* Check the routerstatuses. */
   for (idx = 0; idx < n_vrs; ++idx) {
     vrs = smartlist_get(v1->routerstatus_list, idx);
-    test_assert(vrs);
+    tt_assert(vrs);
     vrs_test(vrs, 1, now);
   }
 
@@ -1365,15 +1365,15 @@ test_a_networkstatus(
 
   /* generate and parse v2. */
   v2_text = format_networkstatus_vote(sign_skey_2, vote);
-  test_assert(v2_text);
+  tt_assert(v2_text);
   v2 = networkstatus_parse_vote_from_string(v2_text, NULL, NS_TYPE_VOTE);
-  test_assert(v2);
+  tt_assert(v2);
 
   if (vote_tweaks) params_tweaked += vote_tweaks(v2, 2, now);
 
   /* Check that flags come out right.*/
   cp = smartlist_join_strings(v2->known_flags, ":", 0, NULL);
-  test_streq(cp, "Authority:Exit:Fast:Guard:MadeOfCheese:MadeOfTin:"
+  tt_str_op(cp,==, "Authority:Exit:Fast:Guard:MadeOfCheese:MadeOfTin:"
              "Running:Stable:V2Dir:Valid");
   tor_free(cp);
 
@@ -1381,7 +1381,7 @@ test_a_networkstatus(
   n_vrs = smartlist_len(v2->routerstatus_list);
   for (idx = 0; idx < n_vrs; ++idx) {
     vrs = smartlist_get(v2->routerstatus_list, idx);
-    test_assert(vrs);
+    tt_assert(vrs);
     vrs_test(vrs, 2, now);
   }
 
@@ -1409,10 +1409,10 @@ test_a_networkstatus(
   memset(voter->legacy_id_digest, (int)'A', DIGEST_LEN);
 
   v3_text = format_networkstatus_vote(sign_skey_3, vote);
-  test_assert(v3_text);
+  tt_assert(v3_text);
 
   v3 = networkstatus_parse_vote_from_string(v3_text, NULL, NS_TYPE_VOTE);
-  test_assert(v3);
+  tt_assert(v3);
 
   if (vote_tweaks) params_tweaked += vote_tweaks(v3, 3, now);
 
@@ -1426,10 +1426,10 @@ test_a_networkstatus(
                                                    "AAAAAAAAAAAAAAAAAAAA",
                                                    sign_skey_leg1,
                                                    FLAV_NS);
-  test_assert(consensus_text);
+  tt_assert(consensus_text);
   con = networkstatus_parse_vote_from_string(consensus_text, NULL,
                                              NS_TYPE_CONSENSUS);
-  test_assert(con);
+  tt_assert(con);
   //log_notice(LD_GENERAL, "<<%s>>\n<<%s>>\n<<%s>>\n",
   //           v1_text, v2_text, v3_text);
   consensus_text_md = networkstatus_compute_consensus(votes, 3,
@@ -1438,38 +1438,38 @@ test_a_networkstatus(
                                                    "AAAAAAAAAAAAAAAAAAAA",
                                                    sign_skey_leg1,
                                                    FLAV_MICRODESC);
-  test_assert(consensus_text_md);
+  tt_assert(consensus_text_md);
   con_md = networkstatus_parse_vote_from_string(consensus_text_md, NULL,
                                                 NS_TYPE_CONSENSUS);
-  test_assert(con_md);
-  test_eq(con_md->flavor, FLAV_MICRODESC);
+  tt_assert(con_md);
+  tt_int_op(con_md->flavor,==, FLAV_MICRODESC);
 
   /* Check consensus contents. */
-  test_assert(con->type == NS_TYPE_CONSENSUS);
-  test_eq(con->published, 0); /* this field only appears in votes. */
-  test_eq(con->valid_after, now+1000);
-  test_eq(con->fresh_until, now+2003); /* median */
-  test_eq(con->valid_until, now+3000);
-  test_eq(con->vote_seconds, 100);
-  test_eq(con->dist_seconds, 250); /* median */
-  test_streq(con->client_versions, "0.1.2.14");
-  test_streq(con->server_versions, "0.1.2.15,0.1.2.16");
+  tt_assert(con->type == NS_TYPE_CONSENSUS);
+  tt_int_op(con->published,==, 0); /* this field only appears in votes. */
+  tt_int_op(con->valid_after,==, now+1000);
+  tt_int_op(con->fresh_until,==, now+2003); /* median */
+  tt_int_op(con->valid_until,==, now+3000);
+  tt_int_op(con->vote_seconds,==, 100);
+  tt_int_op(con->dist_seconds,==, 250); /* median */
+  tt_str_op(con->client_versions,==, "0.1.2.14");
+  tt_str_op(con->server_versions,==, "0.1.2.15,0.1.2.16");
   cp = smartlist_join_strings(v2->known_flags, ":", 0, NULL);
-  test_streq(cp, "Authority:Exit:Fast:Guard:MadeOfCheese:MadeOfTin:"
+  tt_str_op(cp,==, "Authority:Exit:Fast:Guard:MadeOfCheese:MadeOfTin:"
              "Running:Stable:V2Dir:Valid");
   tor_free(cp);
   if (!params_tweaked) {
     /* Skip this one if vote_tweaks() messed with the param lists */
     cp = smartlist_join_strings(con->net_params, ":", 0, NULL);
-    test_streq(cp, "circuitwindow=80:foo=660");
+    tt_str_op(cp,==, "circuitwindow=80:foo=660");
     tor_free(cp);
   }
 
-  test_eq(4, smartlist_len(con->voters)); /*3 voters, 1 legacy key.*/
+  tt_int_op(4,==, smartlist_len(con->voters)); /*3 voters, 1 legacy key.*/
   /* The voter id digests should be in this order. */
-  test_assert(memcmp(cert2->cache_info.identity_digest,
+  tt_assert(memcmp(cert2->cache_info.identity_digest,
                      cert1->cache_info.identity_digest,DIGEST_LEN)<0);
-  test_assert(memcmp(cert1->cache_info.identity_digest,
+  tt_assert(memcmp(cert1->cache_info.identity_digest,
                      cert3->cache_info.identity_digest,DIGEST_LEN)<0);
   test_same_voter(smartlist_get(con->voters, 1),
                   smartlist_get(v2->voters, 0));
@@ -1484,26 +1484,26 @@ test_a_networkstatus(
   n_rs = smartlist_len(con->routerstatus_list);
   for (idx = 0; idx < n_rs; ++idx) {
     rs = smartlist_get(con->routerstatus_list, idx);
-    test_assert(rs);
+    tt_assert(rs);
     rs_test(rs, now);
   }
 
   /* Check signatures.  the first voter is a pseudo-entry with a legacy key.
    * The second one hasn't signed.  The fourth one has signed: validate it. */
   voter = smartlist_get(con->voters, 1);
-  test_eq(smartlist_len(voter->sigs), 0);
+  tt_int_op(smartlist_len(voter->sigs),==, 0);
 
   voter = smartlist_get(con->voters, 3);
-  test_eq(smartlist_len(voter->sigs), 1);
+  tt_int_op(smartlist_len(voter->sigs),==, 1);
   sig = smartlist_get(voter->sigs, 0);
-  test_assert(sig->signature);
-  test_assert(!sig->good_signature);
-  test_assert(!sig->bad_signature);
+  tt_assert(sig->signature);
+  tt_assert(!sig->good_signature);
+  tt_assert(!sig->bad_signature);
 
-  test_assert(!networkstatus_check_document_signature(con, sig, cert3));
-  test_assert(sig->signature);
-  test_assert(sig->good_signature);
-  test_assert(!sig->bad_signature);
+  tt_assert(!networkstatus_check_document_signature(con, sig, cert3));
+  tt_assert(sig->signature);
+  tt_assert(sig->good_signature);
+  tt_assert(!sig->bad_signature);
 
   {
     const char *msg=NULL;
@@ -1526,10 +1526,10 @@ test_a_networkstatus(
                                                       cert1->identity_key,
                                                       sign_skey_1, NULL,NULL,
                                                       FLAV_MICRODESC);
-    test_assert(consensus_text2);
-    test_assert(consensus_text3);
-    test_assert(consensus_text_md2);
-    test_assert(consensus_text_md3);
+    tt_assert(consensus_text2);
+    tt_assert(consensus_text3);
+    tt_assert(consensus_text_md2);
+    tt_assert(consensus_text_md3);
     con2 = networkstatus_parse_vote_from_string(consensus_text2, NULL,
                                                 NS_TYPE_CONSENSUS);
     con3 = networkstatus_parse_vote_from_string(consensus_text3, NULL,
@@ -1538,17 +1538,17 @@ test_a_networkstatus(
                                                 NS_TYPE_CONSENSUS);
     con_md3 = networkstatus_parse_vote_from_string(consensus_text_md3, NULL,
                                                 NS_TYPE_CONSENSUS);
-    test_assert(con2);
-    test_assert(con3);
-    test_assert(con_md2);
-    test_assert(con_md3);
+    tt_assert(con2);
+    tt_assert(con3);
+    tt_assert(con_md2);
+    tt_assert(con_md3);
 
     /* All three should have the same digest. */
-    test_memeq(&con->digests, &con2->digests, sizeof(digests_t));
-    test_memeq(&con->digests, &con3->digests, sizeof(digests_t));
+    tt_mem_op(&con->digests,==, &con2->digests, sizeof(digests_t));
+    tt_mem_op(&con->digests,==, &con3->digests, sizeof(digests_t));
 
-    test_memeq(&con_md->digests, &con_md2->digests, sizeof(digests_t));
-    test_memeq(&con_md->digests, &con_md3->digests, sizeof(digests_t));
+    tt_mem_op(&con_md->digests,==, &con_md2->digests, sizeof(digests_t));
+    tt_mem_op(&con_md->digests,==, &con_md3->digests, sizeof(digests_t));
 
     /* Extract a detached signature from con3. */
     detached_text1 = get_detached_sigs(con3, con_md3);
@@ -1558,50 +1558,50 @@ test_a_networkstatus(
     tt_assert(dsig1);
 
     /* Are parsed values as expected? */
-    test_eq(dsig1->valid_after, con3->valid_after);
-    test_eq(dsig1->fresh_until, con3->fresh_until);
-    test_eq(dsig1->valid_until, con3->valid_until);
+    tt_int_op(dsig1->valid_after,==, con3->valid_after);
+    tt_int_op(dsig1->fresh_until,==, con3->fresh_until);
+    tt_int_op(dsig1->valid_until,==, con3->valid_until);
     {
       digests_t *dsig_digests = strmap_get(dsig1->digests, "ns");
-      test_assert(dsig_digests);
-      test_memeq(dsig_digests->d[DIGEST_SHA1], con3->digests.d[DIGEST_SHA1],
+      tt_assert(dsig_digests);
+      tt_mem_op(dsig_digests->d[DIGEST_SHA1],==, con3->digests.d[DIGEST_SHA1],
                  DIGEST_LEN);
       dsig_digests = strmap_get(dsig1->digests, "microdesc");
-      test_assert(dsig_digests);
-      test_memeq(dsig_digests->d[DIGEST_SHA256],
+      tt_assert(dsig_digests);
+      tt_mem_op(dsig_digests->d[DIGEST_SHA256],==,
                  con_md3->digests.d[DIGEST_SHA256],
                  DIGEST256_LEN);
     }
     {
       smartlist_t *dsig_signatures = strmap_get(dsig1->signatures, "ns");
-      test_assert(dsig_signatures);
-      test_eq(1, smartlist_len(dsig_signatures));
+      tt_assert(dsig_signatures);
+      tt_int_op(1,==, smartlist_len(dsig_signatures));
       sig = smartlist_get(dsig_signatures, 0);
-      test_memeq(sig->identity_digest, cert1->cache_info.identity_digest,
+      tt_mem_op(sig->identity_digest,==, cert1->cache_info.identity_digest,
                  DIGEST_LEN);
-      test_eq(sig->alg, DIGEST_SHA1);
+      tt_int_op(sig->alg,==, DIGEST_SHA1);
 
       dsig_signatures = strmap_get(dsig1->signatures, "microdesc");
-      test_assert(dsig_signatures);
-      test_eq(1, smartlist_len(dsig_signatures));
+      tt_assert(dsig_signatures);
+      tt_int_op(1,==, smartlist_len(dsig_signatures));
       sig = smartlist_get(dsig_signatures, 0);
-      test_memeq(sig->identity_digest, cert1->cache_info.identity_digest,
+      tt_mem_op(sig->identity_digest,==, cert1->cache_info.identity_digest,
                  DIGEST_LEN);
-      test_eq(sig->alg, DIGEST_SHA256);
+      tt_int_op(sig->alg,==, DIGEST_SHA256);
     }
 
     /* Try adding it to con2. */
     detached_text2 = get_detached_sigs(con2,con_md2);
-    test_eq(1, networkstatus_add_detached_signatures(con2, dsig1, "test",
+    tt_int_op(1,==, networkstatus_add_detached_signatures(con2, dsig1, "test",
                                                      LOG_INFO, &msg));
     tor_free(detached_text2);
-    test_eq(1, networkstatus_add_detached_signatures(con_md2, dsig1, "test",
+    tt_int_op(1,==, networkstatus_add_detached_signatures(con_md2, dsig1, "test",
                                                      LOG_INFO, &msg));
     tor_free(detached_text2);
     detached_text2 = get_detached_sigs(con2,con_md2);
     //printf("\n<%s>\n", detached_text2);
     dsig2 = networkstatus_parse_detached_signatures(detached_text2, NULL);
-    test_assert(dsig2);
+    tt_assert(dsig2);
     /*
     printf("\n");
     SMARTLIST_FOREACH(dsig2->signatures, networkstatus_voter_info_t *, vi, {
@@ -1610,28 +1610,28 @@ test_a_networkstatus(
         printf("%s\n", hd);
       });
     */
-    test_eq(2,
+    tt_int_op(2,==,
             smartlist_len((smartlist_t*)strmap_get(dsig2->signatures, "ns")));
-    test_eq(2,
+    tt_int_op(2,==,
             smartlist_len((smartlist_t*)strmap_get(dsig2->signatures,
                                                    "microdesc")));
 
     /* Try adding to con2 twice; verify that nothing changes. */
-    test_eq(0, networkstatus_add_detached_signatures(con2, dsig1, "test",
+    tt_int_op(0,==, networkstatus_add_detached_signatures(con2, dsig1, "test",
                                                      LOG_INFO, &msg));
 
     /* Add to con. */
-    test_eq(2, networkstatus_add_detached_signatures(con, dsig2, "test",
+    tt_int_op(2,==, networkstatus_add_detached_signatures(con, dsig2, "test",
                                                      LOG_INFO, &msg));
     /* Check signatures */
     voter = smartlist_get(con->voters, 1);
     sig = smartlist_get(voter->sigs, 0);
-    test_assert(sig);
-    test_assert(!networkstatus_check_document_signature(con, sig, cert2));
+    tt_assert(sig);
+    tt_assert(!networkstatus_check_document_signature(con, sig, cert2));
     voter = smartlist_get(con->voters, 2);
     sig = smartlist_get(voter->sigs, 0);
-    test_assert(sig);
-    test_assert(!networkstatus_check_document_signature(con, sig, cert1));
+    tt_assert(sig);
+    tt_assert(!networkstatus_check_document_signature(con, sig, cert1));
   }
 
  done:
@@ -1969,7 +1969,7 @@ gen_routerstatus_for_umbw(int idx, time_t now)
       break;
     default:
       /* Shouldn't happen */
-      test_assert(0);
+      tt_assert(0);
   }
   if (vrs) {
     vrs->microdesc = tor_malloc_zero(sizeof(vote_microdesc_hash_t));
@@ -1991,11 +1991,11 @@ vote_tweaks_for_umbw(networkstatus_t *v, int voter, time_t now)
   char *maxbw_param = NULL;
   int rv = 0;
 
-  test_assert(v);
+  tt_assert(v);
   (void)voter;
   (void)now;
 
-  test_assert(v->supported_methods);
+  tt_assert(v->supported_methods);
   SMARTLIST_FOREACH(v->supported_methods, char *, c, tor_free(c));
   smartlist_clear(v->supported_methods);
   /* Method 17 is MIN_METHOD_TO_CLIP_UNMEASURED_BW_KB */
@@ -2005,7 +2005,7 @@ vote_tweaks_for_umbw(networkstatus_t *v, int voter, time_t now)
   /* If we're using a non-default clip bandwidth, add it to net_params */
   if (alternate_clip_bw > 0) {
     tor_asprintf(&maxbw_param, "maxunmeasuredbw=%u", alternate_clip_bw);
-    test_assert(maxbw_param);
+    tt_assert(maxbw_param);
     if (maxbw_param) {
       smartlist_add(v->net_params, maxbw_param);
       rv = 1;
@@ -2028,9 +2028,9 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now)
     alternate_clip_bw : DEFAULT_MAX_UNMEASURED_BW_KB;
 
   (void)voter;
-  test_assert(vrs);
+  tt_assert(vrs);
   rs = &(vrs->status);
-  test_assert(rs);
+  tt_assert(rs);
 
   /* Split out by digests to test */
   if (tor_memeq(rs->identity_digest,
@@ -2041,21 +2041,21 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now)
      * Check the first routerstatus - measured bandwidth below the clip
      * cutoff.
      */
-    test_streq(vrs->version, "0.1.2.14");
-    test_eq(rs->published_on, now-1500);
-    test_streq(rs->nickname, "router2");
-    test_memeq(rs->identity_digest,
+    tt_str_op(vrs->version,==, "0.1.2.14");
+    tt_int_op(rs->published_on,==, now-1500);
+    tt_str_op(rs->nickname,==, "router2");
+    tt_mem_op(rs->identity_digest,==,
                "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3"
                "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3",
                DIGEST_LEN);
-    test_memeq(rs->descriptor_digest, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN);
-    test_eq(rs->addr, 0x99008801);
-    test_eq(rs->or_port, 443);
-    test_eq(rs->dir_port, 8000);
-    test_assert(rs->has_bandwidth);
-    test_assert(vrs->has_measured_bw);
-    test_eq(rs->bandwidth_kb, max_unmeasured_bw_kb / 2);
-    test_eq(vrs->measured_bw_kb, max_unmeasured_bw_kb / 2);
+    tt_mem_op(rs->descriptor_digest,==, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN);
+    tt_int_op(rs->addr,==, 0x99008801);
+    tt_int_op(rs->or_port,==, 443);
+    tt_int_op(rs->dir_port,==, 8000);
+    tt_assert(rs->has_bandwidth);
+    tt_assert(vrs->has_measured_bw);
+    tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb / 2);
+    tt_int_op(vrs->measured_bw_kb,==, max_unmeasured_bw_kb / 2);
   } else if (tor_memeq(rs->identity_digest,
                        "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5"
                        "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5",
@@ -2065,24 +2065,24 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now)
      * Check the second routerstatus - measured bandwidth above the clip
      * cutoff.
      */
-    test_streq(vrs->version, "0.2.0.5");
-    test_eq(rs->published_on, now-1000);
-    test_streq(rs->nickname, "router1");
-    test_memeq(rs->identity_digest,
+    tt_str_op(vrs->version,==, "0.2.0.5");
+    tt_int_op(rs->published_on,==, now-1000);
+    tt_str_op(rs->nickname,==, "router1");
+    tt_mem_op(rs->identity_digest,==,
                "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5"
                "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5",
                DIGEST_LEN);
-    test_memeq(rs->descriptor_digest, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN);
-    test_eq(rs->addr, 0x99009901);
-    test_eq(rs->or_port, 443);
-    test_eq(rs->dir_port, 0);
+    tt_mem_op(rs->descriptor_digest,==, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN);
+    tt_int_op(rs->addr,==, 0x99009901);
+    tt_int_op(rs->or_port,==, 443);
+    tt_int_op(rs->dir_port,==, 0);
     tor_addr_parse(&addr_ipv6, "[1:2:3::4]");
-    test_assert(tor_addr_eq(&rs->ipv6_addr, &addr_ipv6));
-    test_eq(rs->ipv6_orport, 4711);
-    test_assert(rs->has_bandwidth);
-    test_assert(vrs->has_measured_bw);
-    test_eq(rs->bandwidth_kb, max_unmeasured_bw_kb * 2);
-    test_eq(vrs->measured_bw_kb, max_unmeasured_bw_kb * 2);
+    tt_assert(tor_addr_eq(&rs->ipv6_addr, &addr_ipv6));
+    tt_int_op(rs->ipv6_orport,==, 4711);
+    tt_assert(rs->has_bandwidth);
+    tt_assert(vrs->has_measured_bw);
+    tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb * 2);
+    tt_int_op(vrs->measured_bw_kb,==, max_unmeasured_bw_kb * 2);
   } else if (tor_memeq(rs->identity_digest,
                        "\x33\x33\x33\x33\x33\x33\x33\x33\x33\x33"
                        "\x33\x33\x33\x33\x33\x33\x33\x33\x33\x33",
@@ -2092,10 +2092,10 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now)
      * cutoff; this one should be clipped later on in the consensus, but
      * appears unclipped in the vote.
      */
-    test_assert(rs->has_bandwidth);
-    test_assert(!(vrs->has_measured_bw));
-    test_eq(rs->bandwidth_kb, max_unmeasured_bw_kb * 2);
-    test_eq(vrs->measured_bw_kb, 0);
+    tt_assert(rs->has_bandwidth);
+    tt_assert(!(vrs->has_measured_bw));
+    tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb * 2);
+    tt_int_op(vrs->measured_bw_kb,==, 0);
   } else if (tor_memeq(rs->identity_digest,
                        "\x34\x34\x34\x34\x34\x34\x34\x34\x34\x34"
                        "\x34\x34\x34\x34\x34\x34\x34\x34\x34\x34",
@@ -2104,12 +2104,12 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now)
      * Check the fourth routerstatus - unmeasured bandwidth below the clip
      * cutoff; this one should not be clipped.
      */
-    test_assert(rs->has_bandwidth);
-    test_assert(!(vrs->has_measured_bw));
-    test_eq(rs->bandwidth_kb, max_unmeasured_bw_kb / 2);
-    test_eq(vrs->measured_bw_kb, 0);
+    tt_assert(rs->has_bandwidth);
+    tt_assert(!(vrs->has_measured_bw));
+    tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb / 2);
+    tt_int_op(vrs->measured_bw_kb,==, 0);
   } else {
-    test_assert(0);
+    tt_assert(0);
   }
 
  done:
@@ -2124,11 +2124,11 @@ test_consensus_for_umbw(networkstatus_t *con, time_t now)
 {
   (void)now;
 
-  test_assert(con);
-  test_assert(!con->cert);
+  tt_assert(con);
+  tt_assert(!con->cert);
   // test_assert(con->consensus_method >= MIN_METHOD_TO_CLIP_UNMEASURED_BW_KB);
-  test_assert(con->consensus_method >= 16);
-  test_eq(4, smartlist_len(con->routerstatus_list));
+  tt_assert(con->consensus_method >= 16);
+  tt_int_op(4,==, smartlist_len(con->routerstatus_list));
   /* There should be four listed routers; all voters saw the same in this */
 
  done:
@@ -2145,61 +2145,61 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now)
   uint32_t max_unmeasured_bw_kb = (alternate_clip_bw > 0) ?
     alternate_clip_bw : DEFAULT_MAX_UNMEASURED_BW_KB;
 
-  test_assert(rs);
+  tt_assert(rs);
 
   /* There should be four listed routers, as constructed above */
   if (tor_memeq(rs->identity_digest,
                 "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3"
                 "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3",
                 DIGEST_LEN)) {
-    test_memeq(rs->identity_digest,
+    tt_mem_op(rs->identity_digest,==,
                "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3"
                "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3",
                DIGEST_LEN);
-    test_memeq(rs->descriptor_digest, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN);
-    test_assert(!rs->is_authority);
-    test_assert(!rs->is_exit);
-    test_assert(!rs->is_fast);
-    test_assert(!rs->is_possible_guard);
-    test_assert(!rs->is_stable);
+    tt_mem_op(rs->descriptor_digest,==, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN);
+    tt_assert(!rs->is_authority);
+    tt_assert(!rs->is_exit);
+    tt_assert(!rs->is_fast);
+    tt_assert(!rs->is_possible_guard);
+    tt_assert(!rs->is_stable);
     /* (If it wasn't running it wouldn't be here) */
-    test_assert(rs->is_flagged_running);
-    test_assert(!rs->is_valid);
-    test_assert(!rs->is_named);
+    tt_assert(rs->is_flagged_running);
+    tt_assert(!rs->is_valid);
+    tt_assert(!rs->is_named);
     /* This one should have measured bandwidth below the clip cutoff */
-    test_assert(rs->has_bandwidth);
-    test_eq(rs->bandwidth_kb, max_unmeasured_bw_kb / 2);
-    test_assert(!(rs->bw_is_unmeasured));
+    tt_assert(rs->has_bandwidth);
+    tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb / 2);
+    tt_assert(!(rs->bw_is_unmeasured));
   } else if (tor_memeq(rs->identity_digest,
                        "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5"
                        "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5",
                        DIGEST_LEN)) {
     /* This one showed up in 3 digests. Twice with ID 'M', once with 'Z'.  */
-    test_memeq(rs->identity_digest,
+    tt_mem_op(rs->identity_digest,==,
                "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5"
                "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5",
                DIGEST_LEN);
-    test_streq(rs->nickname, "router1");
-    test_memeq(rs->descriptor_digest, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN);
-    test_eq(rs->published_on, now-1000);
-    test_eq(rs->addr, 0x99009901);
-    test_eq(rs->or_port, 443);
-    test_eq(rs->dir_port, 0);
+    tt_str_op(rs->nickname,==, "router1");
+    tt_mem_op(rs->descriptor_digest,==, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN);
+    tt_int_op(rs->published_on,==, now-1000);
+    tt_int_op(rs->addr,==, 0x99009901);
+    tt_int_op(rs->or_port,==, 443);
+    tt_int_op(rs->dir_port,==, 0);
     tor_addr_parse(&addr_ipv6, "[1:2:3::4]");
-    test_assert(tor_addr_eq(&rs->ipv6_addr, &addr_ipv6));
-    test_eq(rs->ipv6_orport, 4711);
-    test_assert(!rs->is_authority);
-    test_assert(rs->is_exit);
-    test_assert(rs->is_fast);
-    test_assert(rs->is_possible_guard);
-    test_assert(rs->is_stable);
-    test_assert(rs->is_flagged_running);
-    test_assert(rs->is_valid);
-    test_assert(!rs->is_named);
+    tt_assert(tor_addr_eq(&rs->ipv6_addr, &addr_ipv6));
+    tt_int_op(rs->ipv6_orport,==, 4711);
+    tt_assert(!rs->is_authority);
+    tt_assert(rs->is_exit);
+    tt_assert(rs->is_fast);
+    tt_assert(rs->is_possible_guard);
+    tt_assert(rs->is_stable);
+    tt_assert(rs->is_flagged_running);
+    tt_assert(rs->is_valid);
+    tt_assert(!rs->is_named);
     /* This one should have measured bandwidth above the clip cutoff */
-    test_assert(rs->has_bandwidth);
-    test_eq(rs->bandwidth_kb, max_unmeasured_bw_kb * 2);
-    test_assert(!(rs->bw_is_unmeasured));
+    tt_assert(rs->has_bandwidth);
+    tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb * 2);
+    tt_assert(!(rs->bw_is_unmeasured));
   } else if (tor_memeq(rs->identity_digest,
                 "\x33\x33\x33\x33\x33\x33\x33\x33\x33\x33"
                 "\x33\x33\x33\x33\x33\x33\x33\x33\x33\x33",
@@ -2208,9 +2208,9 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now)
      * This one should have unmeasured bandwidth above the clip cutoff,
      * and so should be clipped
      */
-    test_assert(rs->has_bandwidth);
-    test_eq(rs->bandwidth_kb, max_unmeasured_bw_kb);
-    test_assert(rs->bw_is_unmeasured);
+    tt_assert(rs->has_bandwidth);
+    tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb);
+    tt_assert(rs->bw_is_unmeasured);
   } else if (tor_memeq(rs->identity_digest,
                 "\x34\x34\x34\x34\x34\x34\x34\x34\x34\x34"
                 "\x34\x34\x34\x34\x34\x34\x34\x34\x34\x34",
@@ -2219,12 +2219,12 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now)
      * This one should have unmeasured bandwidth below the clip cutoff,
      * and so should not be clipped
      */
-    test_assert(rs->has_bandwidth);
-    test_eq(rs->bandwidth_kb, max_unmeasured_bw_kb / 2);
-    test_assert(rs->bw_is_unmeasured);
+    tt_assert(rs->has_bandwidth);
+    tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb / 2);
+    tt_assert(rs->bw_is_unmeasured);
   } else {
     /* Weren't expecting this... */
-    test_assert(0);
+    tt_assert(0);
   }
 
  done:
@@ -2313,60 +2313,60 @@ test_dir_http_handling(void *args)
 
   /* Parse http url tests: */
   /* Good headers */
-  test_eq(parse_http_url("GET /tor/a/b/c.txt HTTP/1.1\r\n"
+  tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.1\r\n"
                            "Host: example.com\r\n"
                            "User-Agent: Mozilla/5.0 (Windows;"
                            " U; Windows NT 6.1; en-US; rv:1.9.1.5)\r\n",
-                           &url), 0);
-  test_streq(url, "/tor/a/b/c.txt");
+                           &url),==, 0);
+  tt_str_op(url,==, "/tor/a/b/c.txt");
   tor_free(url);
 
-  test_eq(parse_http_url("GET /tor/a/b/c.txt HTTP/1.0\r\n", &url), 0);
-  test_streq(url, "/tor/a/b/c.txt");
+  tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.0\r\n", &url),==, 0);
+  tt_str_op(url,==, "/tor/a/b/c.txt");
   tor_free(url);
 
-  test_eq(parse_http_url("GET /tor/a/b/c.txt HTTP/1.600\r\n", &url), 0);
-  test_streq(url, "/tor/a/b/c.txt");
+  tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.600\r\n", &url),==, 0);
+  tt_str_op(url,==, "/tor/a/b/c.txt");
   tor_free(url);
 
   /* Should prepend '/tor/' to url if required */
-  test_eq(parse_http_url("GET /a/b/c.txt HTTP/1.1\r\n"
+  tt_int_op(parse_http_url("GET /a/b/c.txt HTTP/1.1\r\n"
                            "Host: example.com\r\n"
                            "User-Agent: Mozilla/5.0 (Windows;"
                            " U; Windows NT 6.1; en-US; rv:1.9.1.5)\r\n",
-                           &url), 0);
-  test_streq(url, "/tor/a/b/c.txt");
+                           &url),==, 0);
+  tt_str_op(url,==, "/tor/a/b/c.txt");
   tor_free(url);
 
   /* Bad headers -- no HTTP/1.x*/
-  test_eq(parse_http_url("GET /a/b/c.txt\r\n"
+  tt_int_op(parse_http_url("GET /a/b/c.txt\r\n"
                            "Host: example.com\r\n"
                            "User-Agent: Mozilla/5.0 (Windows;"
                            " U; Windows NT 6.1; en-US; rv:1.9.1.5)\r\n",
-                           &url), -1);
+                           &url),==, -1);
   tt_assert(!url);
 
   /* Bad headers */
-  test_eq(parse_http_url("GET /a/b/c.txt\r\n"
+  tt_int_op(parse_http_url("GET /a/b/c.txt\r\n"
                            "Host: example.com\r\n"
                            "User-Agent: Mozilla/5.0 (Windows;"
                            " U; Windows NT 6.1; en-US; rv:1.9.1.5)\r\n",
-                           &url), -1);
+                           &url),==, -1);
   tt_assert(!url);
 
-  test_eq(parse_http_url("GET /tor/a/b/c.txt", &url), -1);
+  tt_int_op(parse_http_url("GET /tor/a/b/c.txt", &url),==, -1);
   tt_assert(!url);
 
-  test_eq(parse_http_url("GET /tor/a/b/c.txt HTTP/1.1", &url), -1);
+  tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.1", &url),==, -1);
   tt_assert(!url);
 
-  test_eq(parse_http_url("GET /tor/a/b/c.txt HTTP/1.1x\r\n", &url), -1);
+  tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.1x\r\n", &url),==, -1);
   tt_assert(!url);
 
-  test_eq(parse_http_url("GET /tor/a/b/c.txt HTTP/1.", &url), -1);
+  tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.", &url),==, -1);
   tt_assert(!url);
 
-  test_eq(parse_http_url("GET /tor/a/b/c.txt HTTP/1.\r", &url), -1);
+  tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.\r", &url),==, -1);
   tt_assert(!url);
 
  done:
diff --git a/src/test/test_entrynodes.c b/src/test/test_entrynodes.c
index fab82c3446..bddc0f11e0 100644
--- a/src/test/test_entrynodes.c
+++ b/src/test/test_entrynodes.c
@@ -139,7 +139,7 @@ test_choose_random_entry_no_guards(void *arg)
   /* Unintuitively, we actually pick a random node as our entry,
      because router_choose_random_node() relaxes its constraints if it
      can't find a proper entry guard. */
-  test_assert(chosen_entry);
+  tt_assert(chosen_entry);
 
  done:
   ;
@@ -201,7 +201,7 @@ populate_live_entry_guards_test_helper(int num_needed)
   SMARTLIST_FOREACH_BEGIN(our_nodelist, const node_t *, node) {
     const node_t *node_tmp;
     node_tmp = add_an_entry_guard(node, 0, 1, 0, 0);
-    test_assert(node_tmp);
+    tt_assert(node_tmp);
   } SMARTLIST_FOREACH_END(node);
 
   /* Make sure the nodes were added as entry guards. */
@@ -650,7 +650,7 @@ test_entry_is_live(void *arg)
   SMARTLIST_FOREACH_BEGIN(our_nodelist, const node_t *, node) {
     const node_t *node_tmp;
     node_tmp = add_an_entry_guard(node, 0, 1, 0, 0);
-    test_assert(node_tmp);
+    tt_assert(node_tmp);
 
     tt_int_op(node->is_stable, ==, 0);
     tt_int_op(node->is_fast, ==, 0);
@@ -670,22 +670,22 @@ test_entry_is_live(void *arg)
   test_node = entry_is_live(test_entry,
                             ENTRY_NEED_UPTIME | ENTRY_ASSUME_REACHABLE,
                             &msg);
-  test_assert(!test_node);
+  tt_assert(!test_node);
 
   /* Require the node to be fast, but it's not. Should fail. */
   test_node = entry_is_live(test_entry,
                             ENTRY_NEED_CAPACITY | ENTRY_ASSUME_REACHABLE,
                             &msg);
-  test_assert(!test_node);
+  tt_assert(!test_node);
 
   /* Don't impose any restrictions on the node. Should succeed. */
   test_node = entry_is_live(test_entry, 0, &msg);
-  test_assert(test_node);
+  tt_assert(test_node);
   tt_ptr_op(test_node, ==, node_get_by_id(test_entry->identity));
 
   /* Require descriptor for this node. It has one so it should succeed. */
   test_node = entry_is_live(test_entry, ENTRY_NEED_DESCRIPTOR, &msg);
-  test_assert(test_node);
+  tt_assert(test_node);
   tt_ptr_op(test_node, ==, node_get_by_id(test_entry->identity));
 
  done:
diff --git a/src/test/test_extorport.c b/src/test/test_extorport.c
index 93c8f77d5b..698bced7e5 100644
--- a/src/test/test_extorport.c
+++ b/src/test/test_extorport.c
@@ -42,7 +42,7 @@ test_ext_or_id_map(void *arg)
 
   /* Give c2 a new ID. */
   connection_or_set_ext_or_identifier(c2);
-  test_mem_op(idp, !=, c2->ext_or_conn_id, EXT_OR_CONN_ID_LEN);
+  tt_mem_op(idp, !=, c2->ext_or_conn_id, EXT_OR_CONN_ID_LEN);
   idp2 = tor_memdup(c2->ext_or_conn_id, EXT_OR_CONN_ID_LEN);
   tt_assert(!tor_digest_is_zero(idp2));
 
@@ -119,7 +119,7 @@ test_ext_or_write_command(void *arg)
             ==, 0);
   cp = buf_get_contents(TO_CONN(c1)->outbuf, &sz);
   tt_int_op(sz, ==, 4);
-  test_mem_op(cp, ==, "\x00\x99\x00\x00", 4);
+  tt_mem_op(cp, ==, "\x00\x99\x00\x00", 4);
   tor_free(cp);
 
   /* Medium command. */
@@ -127,7 +127,7 @@ test_ext_or_write_command(void *arg)
                                             "Wai\0Hello", 9), ==, 0);
   cp = buf_get_contents(TO_CONN(c1)->outbuf, &sz);
   tt_int_op(sz, ==, 13);
-  test_mem_op(cp, ==, "\x00\x99\x00\x09Wai\x00Hello", 13);
+  tt_mem_op(cp, ==, "\x00\x99\x00\x09Wai\x00Hello", 13);
   tor_free(cp);
 
   /* Long command */
@@ -137,8 +137,8 @@ test_ext_or_write_command(void *arg)
                                             buf, 65535), ==, 0);
   cp = buf_get_contents(TO_CONN(c1)->outbuf, &sz);
   tt_int_op(sz, ==, 65539);
-  test_mem_op(cp, ==, "\xf0\x0d\xff\xff", 4);
-  test_mem_op(cp+4, ==, buf, 65535);
+  tt_mem_op(cp, ==, "\xf0\x0d\xff\xff", 4);
+  tt_mem_op(cp+4, ==, buf, 65535);
   tor_free(cp);
 
  done:
@@ -181,7 +181,7 @@ test_ext_or_init_auth(void *arg)
   /* Shouldn't be initialized already, or our tests will be a bit
    * meaningless */
   ext_or_auth_cookie = tor_malloc_zero(32);
-  test_assert(tor_mem_is_zero((char*)ext_or_auth_cookie, 32));
+  tt_assert(tor_mem_is_zero((char*)ext_or_auth_cookie, 32));
 
   /* Now make sure we use a temporary file */
   fn = get_fname("ext_cookie_file");
@@ -203,14 +203,14 @@ test_ext_or_init_auth(void *arg)
   cp = read_file_to_str(fn, RFTS_BIN, &st);
   tt_ptr_op(cp, !=, NULL);
   tt_u64_op((uint64_t)st.st_size, ==, 64);
-  test_memeq(cp, "! Extended ORPort Auth Cookie !\x0a", 32);
-  test_memeq(cp+32, ext_or_auth_cookie, 32);
+  tt_mem_op(cp,==, "! Extended ORPort Auth Cookie !\x0a", 32);
+  tt_mem_op(cp+32,==, ext_or_auth_cookie, 32);
   memcpy(cookie0, ext_or_auth_cookie, 32);
-  test_assert(!tor_mem_is_zero((char*)ext_or_auth_cookie, 32));
+  tt_assert(!tor_mem_is_zero((char*)ext_or_auth_cookie, 32));
 
   /* Operation should be idempotent. */
   tt_int_op(0, ==, init_ext_or_cookie_authentication(1));
-  test_memeq(cookie0, ext_or_auth_cookie, 32);
+  tt_mem_op(cookie0,==, ext_or_auth_cookie, 32);
 
  done:
   tor_free(cp);
@@ -280,15 +280,15 @@ test_ext_or_cookie_auth(void *arg)
                      46+32+32);
   crypto_hmac_sha256(hmac2, (char*)ext_or_auth_cookie, 32, client_hash_input,
                      46+32+32);
-  test_memeq(hmac1, reply, 32);
-  test_memeq(hmac2, client_hash, 32);
+  tt_mem_op(hmac1,==, reply, 32);
+  tt_mem_op(hmac2,==, client_hash, 32);
 
   /* Now do it again and make sure that the results are *different* */
   tt_int_op(0, ==,
             handle_client_auth_nonce(client_nonce, 32, &client_hash2, &reply2,
                                      &reply_len));
-  test_memneq(reply2, reply, reply_len);
-  test_memneq(client_hash2, client_hash, 32);
+  tt_mem_op(reply2,!=, reply, reply_len);
+  tt_mem_op(client_hash2,!=, client_hash, 32);
   /* But that this one checks out too. */
   memcpy(server_hash_input+46+32, reply2+32, 32);
   memcpy(client_hash_input+46+32, reply2+32, 32);
@@ -297,8 +297,8 @@ test_ext_or_cookie_auth(void *arg)
                      46+32+32);
   crypto_hmac_sha256(hmac2, (char*)ext_or_auth_cookie, 32, client_hash_input,
                      46+32+32);
-  test_memeq(hmac1, reply2, 32);
-  test_memeq(hmac2, client_hash2, 32);
+  tt_mem_op(hmac1,==, reply2, 32);
+  tt_mem_op(hmac2,==, client_hash2, 32);
 
  done:
   tor_free(reply);
@@ -339,7 +339,7 @@ test_ext_or_cookie_auth_testvec(void *arg)
                                      &reply_len));
   tt_ptr_op(reply, !=, NULL );
   tt_uint_op(reply_len, ==, 64);
-  test_memeq(reply+32, "te road There is always another ", 32);
+  tt_mem_op(reply+32,==, "te road There is always another ", 32);
   /* HMACSHA256("Gliding wrapt in a brown mantle,"
    *     "ExtORPort authentication server-to-client hash"
    *     "But when I look ahead up the write road There is always another ");
diff --git a/src/test/test_hs.c b/src/test/test_hs.c
index 99ef7dd570..0ee46c2a58 100644
--- a/src/test/test_hs.c
+++ b/src/test/test_hs.c
@@ -84,8 +84,8 @@ test_hs_desc_event(void *arg)
                                         STR_HS_ID);
   expected_msg = "650 HS_DESC REQUESTED "STR_HS_ADDR" NO_AUTH "\
                   STR_HSDIR_EXIST_LONGNAME" "STR_HS_ID"\r\n";
-  test_assert(received_msg);
-  test_streq(received_msg, expected_msg);
+  tt_assert(received_msg);
+  tt_str_op(received_msg,==, expected_msg);
   tor_free(received_msg);
 
   /* test received event */
@@ -93,8 +93,8 @@ test_hs_desc_event(void *arg)
   control_event_hs_descriptor_received(&rend_query, HSDIR_EXIST_ID);
   expected_msg = "650 HS_DESC RECEIVED "STR_HS_ADDR" BASIC_AUTH "\
                   STR_HSDIR_EXIST_LONGNAME"\r\n";
-  test_assert(received_msg);
-  test_streq(received_msg, expected_msg);
+  tt_assert(received_msg);
+  tt_str_op(received_msg,==, expected_msg);
   tor_free(received_msg);
 
   /* test failed event */
@@ -102,8 +102,8 @@ test_hs_desc_event(void *arg)
   control_event_hs_descriptor_failed(&rend_query, HSDIR_NONE_EXIST_ID);
   expected_msg = "650 HS_DESC FAILED "STR_HS_ADDR" STEALTH_AUTH "\
                   STR_HSDIR_NONE_EXIST_LONGNAME"\r\n";
-  test_assert(received_msg);
-  test_streq(received_msg, expected_msg);
+  tt_assert(received_msg);
+  tt_str_op(received_msg,==, expected_msg);
   tor_free(received_msg);
 
   /* test invalid auth type */
@@ -111,8 +111,8 @@ test_hs_desc_event(void *arg)
   control_event_hs_descriptor_failed(&rend_query, HSDIR_EXIST_ID);
   expected_msg = "650 HS_DESC FAILED "STR_HS_ADDR" UNKNOWN "\
                   STR_HSDIR_EXIST_LONGNAME"\r\n";
-  test_assert(received_msg);
-  test_streq(received_msg, expected_msg);
+  tt_assert(received_msg);
+  tt_str_op(received_msg,==, expected_msg);
   tor_free(received_msg);
 
  done:
diff --git a/src/test/test_introduce.c b/src/test/test_introduce.c
index 69c1152229..b841a33d05 100644
--- a/src/test/test_introduce.c
+++ b/src/test/test_introduce.c
@@ -290,48 +290,48 @@ do_parse_test(uint8_t *plaintext, size_t plaintext_len, int phase)
 
   /* Get a key */
   k = crypto_pk_new();
-  test_assert(k);
+  tt_assert(k);
   r = crypto_pk_read_private_key_from_string(k, AUTHORITY_SIGNKEY_1, -1);
-  test_assert(!r);
+  tt_assert(!r);
 
   /* Get digest for future comparison */
   r = crypto_pk_get_digest(k, digest);
-  test_assert(r >= 0);
+  tt_assert(r >= 0);
 
   /* Make a cell out of it */
   r = make_intro_from_plaintext(
       plaintext, plaintext_len,
       k, (void **)(&cell));
-  test_assert(r > 0);
-  test_assert(cell);
+  tt_assert(r > 0);
+  tt_assert(cell);
   cell_len = r;
 
   /* Do early parsing */
   parsed_req = rend_service_begin_parse_intro(cell, cell_len, 2, &err_msg);
-  test_assert(parsed_req);
-  test_assert(!err_msg);
-  test_memeq(parsed_req->pk, digest, DIGEST_LEN);
-  test_assert(parsed_req->ciphertext);
-  test_assert(parsed_req->ciphertext_len > 0);
+  tt_assert(parsed_req);
+  tt_assert(!err_msg);
+  tt_mem_op(parsed_req->pk,==, digest, DIGEST_LEN);
+  tt_assert(parsed_req->ciphertext);
+  tt_assert(parsed_req->ciphertext_len > 0);
 
   if (phase == EARLY_PARSE_ONLY)
     goto done;
 
   /* Do decryption */
   r = rend_service_decrypt_intro(parsed_req, k, &err_msg);
-  test_assert(!r);
-  test_assert(!err_msg);
-  test_assert(parsed_req->plaintext);
-  test_assert(parsed_req->plaintext_len > 0);
+  tt_assert(!r);
+  tt_assert(!err_msg);
+  tt_assert(parsed_req->plaintext);
+  tt_assert(parsed_req->plaintext_len > 0);
 
   if (phase == DECRYPT_ONLY)
     goto done;
 
   /* Do late parsing */
   r = rend_service_parse_intro_plaintext(parsed_req, &err_msg);
-  test_assert(!r);
-  test_assert(!err_msg);
-  test_assert(parsed_req->parsed);
+  tt_assert(!r);
+  tt_assert(!err_msg);
+  tt_assert(parsed_req->parsed);
 
  done:
   tor_free(cell);
@@ -371,14 +371,14 @@ make_intro_from_plaintext(
 
   /* Compute key digest (will be first DIGEST_LEN octets of cell) */
   r = crypto_pk_get_digest(key, cell);
-  test_assert(r >= 0);
+  tt_assert(r >= 0);
 
   /* Do encryption */
   r = crypto_pk_public_hybrid_encrypt(
       key, cell + DIGEST_LEN, ciphertext_size,
       buf, len,
       PK_PKCS1_OAEP_PADDING, 0);
-  test_assert(r >= 0);
+  tt_assert(r >= 0);
 
   /* Figure out cell length */
   cell_len = DIGEST_LEN + r;
diff --git a/src/test/test_microdesc.c b/src/test/test_microdesc.c
index 78f4823b87..23e636fbf1 100644
--- a/src/test/test_microdesc.c
+++ b/src/test/test_microdesc.c
@@ -108,7 +108,7 @@ test_md_cache(void *data)
   md2 = smartlist_get(added, 0);
   /* And it should have gotten removed from 'wanted' */
   tt_int_op(smartlist_len(wanted), ==, 1);
-  test_mem_op(smartlist_get(wanted, 0), ==, d3, DIGEST256_LEN);
+  tt_mem_op(smartlist_get(wanted, 0), ==, d3, DIGEST256_LEN);
   smartlist_free(added);
   added = NULL;
 
@@ -144,18 +144,18 @@ test_md_cache(void *data)
   tt_int_op(md1->bodylen, ==, strlen(test_md1));
   tt_int_op(md2->bodylen, ==, strlen(test_md2));
   tt_int_op(md3->bodylen, ==, strlen(test_md3_noannotation));
-  test_mem_op(md1->body, ==, test_md1, strlen(test_md1));
-  test_mem_op(md2->body, ==, test_md2, strlen(test_md2));
-  test_mem_op(md3->body, ==, test_md3_noannotation,
+  tt_mem_op(md1->body, ==, test_md1, strlen(test_md1));
+  tt_mem_op(md2->body, ==, test_md2, strlen(test_md2));
+  tt_mem_op(md3->body, ==, test_md3_noannotation,
               strlen(test_md3_noannotation));
 
   tor_asprintf(&fn, "%s"PATH_SEPARATOR"cached-microdescs.new",
                options->DataDirectory);
   s = read_file_to_str(fn, RFTS_BIN, NULL);
   tt_assert(s);
-  test_mem_op(md1->body, ==, s + md1->off, md1->bodylen);
-  test_mem_op(md2->body, ==, s + md2->off, md2->bodylen);
-  test_mem_op(md3->body, ==, s + md3->off, md3->bodylen);
+  tt_mem_op(md1->body, ==, s + md1->off, md1->bodylen);
+  tt_mem_op(md2->body, ==, s + md2->off, md2->bodylen);
+  tt_mem_op(md3->body, ==, s + md3->off, md3->bodylen);
 
   tt_ptr_op(md1->family, ==, NULL);
   tt_ptr_op(md3->family, !=, NULL);
@@ -180,9 +180,9 @@ test_md_cache(void *data)
   tor_asprintf(&fn, "%s"PATH_SEPARATOR"cached-microdescs",
                options->DataDirectory);
   s = read_file_to_str(fn, RFTS_BIN, NULL);
-  test_mem_op(md1->body, ==, s + md1->off, strlen(test_md1));
-  test_mem_op(md2->body, ==, s + md2->off, strlen(test_md2));
-  test_mem_op(md3->body, ==, s + md3->off, strlen(test_md3_noannotation));
+  tt_mem_op(md1->body, ==, s + md1->off, strlen(test_md1));
+  tt_mem_op(md2->body, ==, s + md2->off, strlen(test_md2));
+  tt_mem_op(md3->body, ==, s + md3->off, strlen(test_md3_noannotation));
 
   /* Okay, now we are going to forget about the cache entirely, and reload it
    * from the disk. */
@@ -191,12 +191,12 @@ test_md_cache(void *data)
   md1 = microdesc_cache_lookup_by_digest256(mc, d1);
   md2 = microdesc_cache_lookup_by_digest256(mc, d2);
   md3 = microdesc_cache_lookup_by_digest256(mc, d3);
-  test_assert(md1);
-  test_assert(md2);
-  test_assert(md3);
-  test_mem_op(md1->body, ==, s + md1->off, strlen(test_md1));
-  test_mem_op(md2->body, ==, s + md2->off, strlen(test_md2));
-  test_mem_op(md3->body, ==, s + md3->off, strlen(test_md3_noannotation));
+  tt_assert(md1);
+  tt_assert(md2);
+  tt_assert(md3);
+  tt_mem_op(md1->body, ==, s + md1->off, strlen(test_md1));
+  tt_mem_op(md2->body, ==, s + md2->off, strlen(test_md2));
+  tt_mem_op(md3->body, ==, s + md3->off, strlen(test_md3_noannotation));
 
   tt_int_op(md1->last_listed, ==, time1);
   tt_int_op(md2->last_listed, ==, time2);
diff --git a/src/test/test_nodelist.c b/src/test/test_nodelist.c
index 600e6a89d4..6d270db960 100644
--- a/src/test/test_nodelist.c
+++ b/src/test/test_nodelist.c
@@ -23,9 +23,9 @@ test_nodelist_node_get_verbose_nickname_by_id_null_node(void *arg)
   (void) arg;
 
   /* make sure node_get_by_id returns NULL */
-  test_assert(!node_get_by_id(ID));
+  tt_assert(!node_get_by_id(ID));
   node_get_verbose_nickname_by_id(ID, vname);
-  test_streq(vname, "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
+  tt_str_op(vname,==, "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
  done:
   return;
 }
@@ -54,7 +54,7 @@ test_nodelist_node_get_verbose_nickname_not_named(void *arg)
           "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA",
           DIGEST_LEN);
   node_get_verbose_nickname(&mock_node, vname);
-  test_streq(vname, "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA~TestOR");
+  tt_str_op(vname,==, "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA~TestOR");
 
  done:
   return;
diff --git a/src/test/test_policy.c b/src/test/test_policy.c
index 4cdcd034bb..61a5449c15 100644
--- a/src/test/test_policy.c
+++ b/src/test/test_policy.c
@@ -48,16 +48,16 @@ test_policy_summary_helper(const char *policy_str,
   line.next = NULL;
 
   r = policies_parse_exit_policy(&line, &policy, 1, 0, 0, 1);
-  test_eq(r, 0);
+  tt_int_op(r,==, 0);
   summary = policy_summarize(policy, AF_INET);
 
-  test_assert(summary != NULL);
-  test_streq(summary, expected_summary);
+  tt_assert(summary != NULL);
+  tt_str_op(summary,==, expected_summary);
 
   short_policy = parse_short_policy(summary);
   tt_assert(short_policy);
   summary_after = write_short_policy(short_policy);
-  test_streq(summary, summary_after);
+  tt_str_op(summary,==, summary_after);
 
  done:
   tor_free(summary_after);
@@ -86,104 +86,104 @@ test_policies_general(void *arg)
   policy = smartlist_new();
 
   p = router_parse_addr_policy_item_from_string("reject 192.168.0.0/16:*",-1);
-  test_assert(p != NULL);
-  test_eq(ADDR_POLICY_REJECT, p->policy_type);
+  tt_assert(p != NULL);
+  tt_int_op(ADDR_POLICY_REJECT,==, p->policy_type);
   tor_addr_from_ipv4h(&tar, 0xc0a80000u);
-  test_eq(0, tor_addr_compare(&p->addr, &tar, CMP_EXACT));
-  test_eq(16, p->maskbits);
-  test_eq(1, p->prt_min);
-  test_eq(65535, p->prt_max);
+  tt_int_op(0,==, tor_addr_compare(&p->addr, &tar, CMP_EXACT));
+  tt_int_op(16,==, p->maskbits);
+  tt_int_op(1,==, p->prt_min);
+  tt_int_op(65535,==, p->prt_max);
 
   smartlist_add(policy, p);
 
   tor_addr_from_ipv4h(&tar, 0x01020304u);
-  test_assert(ADDR_POLICY_ACCEPTED ==
+  tt_assert(ADDR_POLICY_ACCEPTED ==
           compare_tor_addr_to_addr_policy(&tar, 2, policy));
   tor_addr_make_unspec(&tar);
-  test_assert(ADDR_POLICY_PROBABLY_ACCEPTED ==
+  tt_assert(ADDR_POLICY_PROBABLY_ACCEPTED ==
           compare_tor_addr_to_addr_policy(&tar, 2, policy));
   tor_addr_from_ipv4h(&tar, 0xc0a80102);
-  test_assert(ADDR_POLICY_REJECTED ==
+  tt_assert(ADDR_POLICY_REJECTED ==
           compare_tor_addr_to_addr_policy(&tar, 2, policy));
 
-  test_assert(0 == policies_parse_exit_policy(NULL, &policy2, 1, 1, 0, 1));
-  test_assert(policy2);
+  tt_assert(0 == policies_parse_exit_policy(NULL, &policy2, 1, 1, 0, 1));
+  tt_assert(policy2);
 
   policy3 = smartlist_new();
   p = router_parse_addr_policy_item_from_string("reject *:*",-1);
-  test_assert(p != NULL);
+  tt_assert(p != NULL);
   smartlist_add(policy3, p);
   p = router_parse_addr_policy_item_from_string("accept *:*",-1);
-  test_assert(p != NULL);
+  tt_assert(p != NULL);
   smartlist_add(policy3, p);
 
   policy4 = smartlist_new();
   p = router_parse_addr_policy_item_from_string("accept *:443",-1);
-  test_assert(p != NULL);
+  tt_assert(p != NULL);
   smartlist_add(policy4, p);
   p = router_parse_addr_policy_item_from_string("accept *:443",-1);
-  test_assert(p != NULL);
+  tt_assert(p != NULL);
   smartlist_add(policy4, p);
 
   policy5 = smartlist_new();
   p = router_parse_addr_policy_item_from_string("reject 0.0.0.0/8:*",-1);
-  test_assert(p != NULL);
+  tt_assert(p != NULL);
   smartlist_add(policy5, p);
   p = router_parse_addr_policy_item_from_string("reject 169.254.0.0/16:*",-1);
-  test_assert(p != NULL);
+  tt_assert(p != NULL);
   smartlist_add(policy5, p);
   p = router_parse_addr_policy_item_from_string("reject 127.0.0.0/8:*",-1);
-  test_assert(p != NULL);
+  tt_assert(p != NULL);
   smartlist_add(policy5, p);
   p = router_parse_addr_policy_item_from_string("reject 192.168.0.0/16:*",-1);
-  test_assert(p != NULL);
+  tt_assert(p != NULL);
   smartlist_add(policy5, p);
   p = router_parse_addr_policy_item_from_string("reject 10.0.0.0/8:*",-1);
-  test_assert(p != NULL);
+  tt_assert(p != NULL);
   smartlist_add(policy5, p);
   p = router_parse_addr_policy_item_from_string("reject 172.16.0.0/12:*",-1);
-  test_assert(p != NULL);
+  tt_assert(p != NULL);
   smartlist_add(policy5, p);
   p = router_parse_addr_policy_item_from_string("reject 80.190.250.90:*",-1);
-  test_assert(p != NULL);
+  tt_assert(p != NULL);
   smartlist_add(policy5, p);
   p = router_parse_addr_policy_item_from_string("reject *:1-65534",-1);
-  test_assert(p != NULL);
+  tt_assert(p != NULL);
   smartlist_add(policy5, p);
   p = router_parse_addr_policy_item_from_string("reject *:65535",-1);
-  test_assert(p != NULL);
+  tt_assert(p != NULL);
   smartlist_add(policy5, p);
   p = router_parse_addr_policy_item_from_string("accept *:1-65535",-1);
-  test_assert(p != NULL);
+  tt_assert(p != NULL);
   smartlist_add(policy5, p);
 
   policy6 = smartlist_new();
   p = router_parse_addr_policy_item_from_string("accept 43.3.0.0/9:*",-1);
-  test_assert(p != NULL);
+  tt_assert(p != NULL);
   smartlist_add(policy6, p);
 
   policy7 = smartlist_new();
   p = router_parse_addr_policy_item_from_string("accept 0.0.0.0/8:*",-1);
-  test_assert(p != NULL);
+  tt_assert(p != NULL);
   smartlist_add(policy7, p);
 
-  test_assert(!exit_policy_is_general_exit(policy));
-  test_assert(exit_policy_is_general_exit(policy2));
-  test_assert(!exit_policy_is_general_exit(NULL));
-  test_assert(!exit_policy_is_general_exit(policy3));
-  test_assert(!exit_policy_is_general_exit(policy4));
-  test_assert(!exit_policy_is_general_exit(policy5));
-  test_assert(!exit_policy_is_general_exit(policy6));
-  test_assert(!exit_policy_is_general_exit(policy7));
+  tt_assert(!exit_policy_is_general_exit(policy));
+  tt_assert(exit_policy_is_general_exit(policy2));
+  tt_assert(!exit_policy_is_general_exit(NULL));
+  tt_assert(!exit_policy_is_general_exit(policy3));
+  tt_assert(!exit_policy_is_general_exit(policy4));
+  tt_assert(!exit_policy_is_general_exit(policy5));
+  tt_assert(!exit_policy_is_general_exit(policy6));
+  tt_assert(!exit_policy_is_general_exit(policy7));
 
-  test_assert(cmp_addr_policies(policy, policy2));
-  test_assert(cmp_addr_policies(policy, NULL));
-  test_assert(!cmp_addr_policies(policy2, policy2));
-  test_assert(!cmp_addr_policies(NULL, NULL));
+  tt_assert(cmp_addr_policies(policy, policy2));
+  tt_assert(cmp_addr_policies(policy, NULL));
+  tt_assert(!cmp_addr_policies(policy2, policy2));
+  tt_assert(!cmp_addr_policies(NULL, NULL));
 
-  test_assert(!policy_is_reject_star(policy2, AF_INET));
-  test_assert(policy_is_reject_star(policy, AF_INET));
-  test_assert(policy_is_reject_star(NULL, AF_INET));
+  tt_assert(!policy_is_reject_star(policy2, AF_INET));
+  tt_assert(policy_is_reject_star(policy, AF_INET));
+  tt_assert(policy_is_reject_star(NULL, AF_INET));
 
   addr_policy_list_free(policy);
   policy = NULL;
@@ -193,11 +193,11 @@ test_policies_general(void *arg)
   line.key = (char*)"foo";
   line.value = (char*)"accept *:80,reject private:*,reject *:*";
   line.next = NULL;
-  test_assert(0 == policies_parse_exit_policy(&line, &policy, 1, 0, 0, 1));
-  test_assert(policy);
+  tt_assert(0 == policies_parse_exit_policy(&line, &policy, 1, 0, 0, 1));
+  tt_assert(policy);
   //test_streq(policy->string, "accept *:80");
   //test_streq(policy->next->string, "reject *:*");
-  test_eq(smartlist_len(policy), 4);
+  tt_int_op(smartlist_len(policy),==, 4);
 
   /* test policy summaries */
   /* check if we properly ignore private IP addresses */
@@ -359,7 +359,7 @@ test_dump_exit_policy_to_string(void *arg)
  ri->exit_policy = NULL; // expecting "reject *:*"
  ep = router_dump_exit_policy_to_string(ri,1,1);
 
- test_streq("reject *:*",ep);
+ tt_str_op("reject *:*",==, ep);
 
  tor_free(ep);
 
@@ -372,7 +372,7 @@ test_dump_exit_policy_to_string(void *arg)
 
  ep = router_dump_exit_policy_to_string(ri,1,1);
 
- test_streq("accept *:*",ep);
+ tt_str_op("accept *:*",==, ep);
 
  tor_free(ep);
 
@@ -382,7 +382,7 @@ test_dump_exit_policy_to_string(void *arg)
 
  ep = router_dump_exit_policy_to_string(ri,1,1);
 
- test_streq("accept *:*\nreject *:25",ep);
+ tt_str_op("accept *:*\nreject *:25",==, ep);
 
  tor_free(ep);
 
@@ -393,7 +393,7 @@ test_dump_exit_policy_to_string(void *arg)
 
  ep = router_dump_exit_policy_to_string(ri,1,1);
 
- test_streq("accept *:*\nreject *:25\nreject 8.8.8.8:*",ep);
+ tt_str_op("accept *:*\nreject *:25\nreject 8.8.8.8:*",==, ep);
  tor_free(ep);
 
  policy_entry =
@@ -403,8 +403,8 @@ test_dump_exit_policy_to_string(void *arg)
 
  ep = router_dump_exit_policy_to_string(ri,1,1);
 
- test_streq("accept *:*\nreject *:25\nreject 8.8.8.8:*\n"
-            "reject6 [fc00::]/7:*",ep);
+ tt_str_op("accept *:*\nreject *:25\nreject 8.8.8.8:*\n"
+            "reject6 [fc00::]/7:*",==, ep);
  tor_free(ep);
 
  policy_entry =
@@ -414,8 +414,8 @@ test_dump_exit_policy_to_string(void *arg)
 
  ep = router_dump_exit_policy_to_string(ri,1,1);
 
- test_streq("accept *:*\nreject *:25\nreject 8.8.8.8:*\n"
-            "reject6 [fc00::]/7:*\naccept6 [c000::]/3:*",ep);
+ tt_str_op("accept *:*\nreject *:25\nreject 8.8.8.8:*\n"
+            "reject6 [fc00::]/7:*\naccept6 [c000::]/3:*",==, ep);
 
  done:
 
diff --git a/src/test/test_pt.c b/src/test/test_pt.c
index 0737ff4892..aa616abf3e 100644
--- a/src/test/test_pt.c
+++ b/src/test/test_pt.c
@@ -39,63 +39,63 @@ test_pt_parsing(void)
 
   /* incomplete cmethod */
   strlcpy(line,"CMETHOD trebuchet",sizeof(line));
-  test_assert(parse_cmethod_line(line, mp) < 0);
+  tt_assert(parse_cmethod_line(line, mp) < 0);
 
   reset_mp(mp);
 
   /* wrong proxy type */
   strlcpy(line,"CMETHOD trebuchet dog 127.0.0.1:1999",sizeof(line));
-  test_assert(parse_cmethod_line(line, mp) < 0);
+  tt_assert(parse_cmethod_line(line, mp) < 0);
 
   reset_mp(mp);
 
   /* wrong addrport */
   strlcpy(line,"CMETHOD trebuchet socks4 abcd",sizeof(line));
-  test_assert(parse_cmethod_line(line, mp) < 0);
+  tt_assert(parse_cmethod_line(line, mp) < 0);
 
   reset_mp(mp);
 
   /* correct line */
   strlcpy(line,"CMETHOD trebuchet socks5 127.0.0.1:1999",sizeof(line));
-  test_assert(parse_cmethod_line(line, mp) == 0);
-  test_assert(smartlist_len(mp->transports) == 1);
+  tt_assert(parse_cmethod_line(line, mp) == 0);
+  tt_assert(smartlist_len(mp->transports) == 1);
   transport = smartlist_get(mp->transports, 0);
   /* test registered address of transport */
   tor_addr_parse(&test_addr, "127.0.0.1");
-  test_assert(tor_addr_eq(&test_addr, &transport->addr));
+  tt_assert(tor_addr_eq(&test_addr, &transport->addr));
   /* test registered port of transport */
-  test_assert(transport->port == 1999);
+  tt_assert(transport->port == 1999);
   /* test registered SOCKS version of transport */
-  test_assert(transport->socks_version == PROXY_SOCKS5);
+  tt_assert(transport->socks_version == PROXY_SOCKS5);
   /* test registered name of transport */
-  test_streq(transport->name, "trebuchet");
+  tt_str_op(transport->name,==, "trebuchet");
 
   reset_mp(mp);
 
   /* incomplete smethod */
   strlcpy(line,"SMETHOD trebuchet",sizeof(line));
-  test_assert(parse_smethod_line(line, mp) < 0);
+  tt_assert(parse_smethod_line(line, mp) < 0);
 
   reset_mp(mp);
 
   /* wrong addr type */
   strlcpy(line,"SMETHOD trebuchet abcd",sizeof(line));
-  test_assert(parse_smethod_line(line, mp) < 0);
+  tt_assert(parse_smethod_line(line, mp) < 0);
 
   reset_mp(mp);
 
   /* cowwect */
   strlcpy(line,"SMETHOD trebuchy 127.0.0.2:2999",sizeof(line));
-  test_assert(parse_smethod_line(line, mp) == 0);
-  test_assert(smartlist_len(mp->transports) == 1);
+  tt_assert(parse_smethod_line(line, mp) == 0);
+  tt_assert(smartlist_len(mp->transports) == 1);
   transport = smartlist_get(mp->transports, 0);
   /* test registered address of transport */
   tor_addr_parse(&test_addr, "127.0.0.2");
-  test_assert(tor_addr_eq(&test_addr, &transport->addr));
+  tt_assert(tor_addr_eq(&test_addr, &transport->addr));
   /* test registered port of transport */
-  test_assert(transport->port == 2999);
+  tt_assert(transport->port == 2999);
   /* test registered name of transport */
-  test_streq(transport->name, "trebuchy");
+  tt_str_op(transport->name,==, "trebuchy");
 
   reset_mp(mp);
 
@@ -103,7 +103,7 @@ test_pt_parsing(void)
   strlcpy(line,"SMETHOD trebuchet 127.0.0.1:9999 "
           "ARGS:counterweight=3,sling=snappy",
           sizeof(line));
-  test_assert(parse_smethod_line(line, mp) == 0);
+  tt_assert(parse_smethod_line(line, mp) == 0);
   tt_int_op(1, ==, smartlist_len(mp->transports));
   {
     const transport_t *transport = smartlist_get(mp->transports, 0);
@@ -118,15 +118,15 @@ test_pt_parsing(void)
 
   /* unsupported version */
   strlcpy(line,"VERSION 666",sizeof(line));
-  test_assert(parse_version(line, mp) < 0);
+  tt_assert(parse_version(line, mp) < 0);
 
   /* incomplete VERSION */
   strlcpy(line,"VERSION ",sizeof(line));
-  test_assert(parse_version(line, mp) < 0);
+  tt_assert(parse_version(line, mp) < 0);
 
   /* correct VERSION */
   strlcpy(line,"VERSION 1",sizeof(line));
-  test_assert(parse_version(line, mp) == 0);
+  tt_assert(parse_version(line, mp) == 0);
 
  done:
   reset_mp(mp);
@@ -201,32 +201,32 @@ test_pt_protocol(void)
 
   strlcpy(line,"VERSION 1",sizeof(line));
   handle_proxy_line(line, mp);
-  test_assert(mp->conf_state == PT_PROTO_ACCEPTING_METHODS);
+  tt_assert(mp->conf_state == PT_PROTO_ACCEPTING_METHODS);
 
   strlcpy(line,"VERSION 1",sizeof(line));
   handle_proxy_line(line, mp);
-  test_assert(mp->conf_state == PT_PROTO_BROKEN);
+  tt_assert(mp->conf_state == PT_PROTO_BROKEN);
 
   reset_mp(mp);
 
   strlcpy(line,"CMETHOD trebuchet socks5 127.0.0.1:1999",sizeof(line));
   handle_proxy_line(line, mp);
-  test_assert(mp->conf_state == PT_PROTO_BROKEN);
+  tt_assert(mp->conf_state == PT_PROTO_BROKEN);
 
   reset_mp(mp);
 
   /* correct protocol run: */
   strlcpy(line,"VERSION 1",sizeof(line));
   handle_proxy_line(line, mp);
-  test_assert(mp->conf_state == PT_PROTO_ACCEPTING_METHODS);
+  tt_assert(mp->conf_state == PT_PROTO_ACCEPTING_METHODS);
 
   strlcpy(line,"CMETHOD trebuchet socks5 127.0.0.1:1999",sizeof(line));
   handle_proxy_line(line, mp);
-  test_assert(mp->conf_state == PT_PROTO_ACCEPTING_METHODS);
+  tt_assert(mp->conf_state == PT_PROTO_ACCEPTING_METHODS);
 
   strlcpy(line,"CMETHODS DONE",sizeof(line));
   handle_proxy_line(line, mp);
-  test_assert(mp->conf_state == PT_PROTO_CONFIGURED);
+  tt_assert(mp->conf_state == PT_PROTO_CONFIGURED);
 
  done:
   reset_mp(mp);
@@ -378,19 +378,19 @@ test_pt_configure_proxy(void *arg)
   for (i = 0 ; i < 5 ; i++) {
     retval = configure_proxy(mp);
     /* retval should be zero because proxy hasn't finished configuring yet */
-    test_assert(retval == 0);
+    tt_int_op(retval, ==, 0);
     /* check the number of registered transports */
-    test_assert(smartlist_len(mp->transports) == i+1);
+    tt_assert(smartlist_len(mp->transports) == i+1);
     /* check that the mp is still waiting for transports */
-    test_assert(mp->conf_state == PT_PROTO_ACCEPTING_METHODS);
+    tt_assert(mp->conf_state == PT_PROTO_ACCEPTING_METHODS);
   }
 
   /* this last configure_proxy() should finalize the proxy configuration. */
   retval = configure_proxy(mp);
   /* retval should be 1 since the proxy finished configuring */
-  test_assert(retval == 1);
+  tt_int_op(retval, ==, 1);
   /* check the mp state */
-  test_assert(mp->conf_state == PT_PROTO_COMPLETED);
+  tt_assert(mp->conf_state == PT_PROTO_COMPLETED);
 
   tt_int_op(controlevent_n, ==, 5);
   tt_int_op(controlevent_event, ==, EVENT_TRANSPORT_LAUNCHED);
@@ -416,7 +416,7 @@ test_pt_configure_proxy(void *arg)
     /* Get the bindaddr for "mock1" and check it against the bindaddr
        that the mocked tor_get_lines_from_handle() generated. */
     transport_in_state = get_transport_in_state_by_name("mock1");
-    test_assert(transport_in_state);
+    tt_assert(transport_in_state);
     smartlist_split_string(transport_info_sl, transport_in_state->value,
                            NULL, 0, 0);
     name_of_transport = smartlist_get(transport_info_sl, 0);
@@ -468,7 +468,7 @@ test_get_pt_proxy_uri(void *arg)
   ret = tor_addr_port_lookup(options->Socks4Proxy,
                              &options->Socks4ProxyAddr,
                              &options->Socks4ProxyPort);
-  tt_assert(ret == 0);
+  tt_int_op(ret, ==, 0);
   uri = get_pt_proxy_uri();
   tt_str_op(uri, ==, "socks4a://192.0.2.1:1080");
   tor_free(uri);
@@ -479,7 +479,7 @@ test_get_pt_proxy_uri(void *arg)
   ret = tor_addr_port_lookup(options->Socks5Proxy,
                              &options->Socks5ProxyAddr,
                              &options->Socks5ProxyPort);
-  tt_assert(ret == 0);
+  tt_int_op(ret, ==, 0);
   uri = get_pt_proxy_uri();
   tt_str_op(uri, ==, "socks5://192.0.2.1:1080");
   tor_free(uri);
@@ -499,7 +499,7 @@ test_get_pt_proxy_uri(void *arg)
   ret = tor_addr_port_lookup(options->HTTPSProxy,
                              &options->HTTPSProxyAddr,
                              &options->HTTPSProxyPort);
-  tt_assert(ret == 0);
+  tt_int_op(ret, ==, 0);
   uri = get_pt_proxy_uri();
   tt_str_op(uri, ==, "http://192.0.2.1:80");
   tor_free(uri);
@@ -517,7 +517,7 @@ test_get_pt_proxy_uri(void *arg)
   ret = tor_addr_port_lookup(options->Socks4Proxy,
                              &options->Socks4ProxyAddr,
                              &options->Socks4ProxyPort);
-  tt_assert(ret == 0);
+  tt_int_op(ret, ==, 0);
   uri = get_pt_proxy_uri();
   tt_str_op(uri, ==, "socks4a://[2001:db8::1]:1080");
   tor_free(uri);
diff --git a/src/test/test_replay.c b/src/test/test_replay.c
index b48f582f5e..d5e039ec26 100644
--- a/src/test/test_replay.c
+++ b/src/test/test_replay.c
@@ -23,7 +23,7 @@ test_replaycache_alloc(void)
   replaycache_t *r = NULL;
 
   r = replaycache_new(600, 300);
-  test_assert(r != NULL);
+  tt_assert(r != NULL);
 
  done:
   if (r) replaycache_free(r);
@@ -38,15 +38,15 @@ test_replaycache_badalloc(void)
 
   /* Negative horizon should fail */
   r = replaycache_new(-600, 300);
-  test_assert(r == NULL);
+  tt_assert(r == NULL);
   /* Negative interval should get adjusted to zero */
   r = replaycache_new(600, -300);
-  test_assert(r != NULL);
-  test_eq(r->scrub_interval, 0);
+  tt_assert(r != NULL);
+  tt_int_op(r->scrub_interval,==, 0);
   replaycache_free(r);
   /* Negative horizon and negative interval should still fail */
   r = replaycache_new(-600, -300);
-  test_assert(r == NULL);
+  tt_assert(r == NULL);
 
  done:
   if (r) replaycache_free(r);
@@ -59,7 +59,7 @@ test_replaycache_free_null(void)
 {
   replaycache_free(NULL);
   /* Assert that we're here without horrible death */
-  test_assert(1);
+  tt_assert(1);
 
  done:
   return;
@@ -72,18 +72,18 @@ test_replaycache_miss(void)
   int result;
 
   r = replaycache_new(600, 300);
-  test_assert(r != NULL);
+  tt_assert(r != NULL);
 
   result =
     replaycache_add_and_test_internal(1200, r, test_buffer,
         strlen(test_buffer), NULL);
-  test_eq(result, 0);
+  tt_int_op(result,==, 0);
 
   /* poke the bad-parameter error case too */
   result =
     replaycache_add_and_test_internal(1200, NULL, test_buffer,
         strlen(test_buffer), NULL);
-  test_eq(result, 0);
+  tt_int_op(result,==, 0);
 
  done:
   if (r) replaycache_free(r);
@@ -98,17 +98,17 @@ test_replaycache_hit(void)
   int result;
 
   r = replaycache_new(600, 300);
-  test_assert(r != NULL);
+  tt_assert(r != NULL);
 
   result =
     replaycache_add_and_test_internal(1200, r, test_buffer,
         strlen(test_buffer), NULL);
-  test_eq(result, 0);
+  tt_int_op(result,==, 0);
 
   result =
     replaycache_add_and_test_internal(1300, r, test_buffer,
         strlen(test_buffer), NULL);
-  test_eq(result, 1);
+  tt_int_op(result,==, 1);
 
  done:
   if (r) replaycache_free(r);
@@ -123,22 +123,22 @@ test_replaycache_age(void)
   int result;
 
   r = replaycache_new(600, 300);
-  test_assert(r != NULL);
+  tt_assert(r != NULL);
 
   result =
     replaycache_add_and_test_internal(1200, r, test_buffer,
         strlen(test_buffer), NULL);
-  test_eq(result, 0);
+  tt_int_op(result,==, 0);
 
   result =
     replaycache_add_and_test_internal(1300, r, test_buffer,
         strlen(test_buffer), NULL);
-  test_eq(result, 1);
+  tt_int_op(result,==, 1);
 
   result =
     replaycache_add_and_test_internal(3000, r, test_buffer,
         strlen(test_buffer), NULL);
-  test_eq(result, 0);
+  tt_int_op(result,==, 0);
 
  done:
   if (r) replaycache_free(r);
@@ -154,18 +154,18 @@ test_replaycache_elapsed(void)
   time_t elapsed;
 
   r = replaycache_new(600, 300);
-  test_assert(r != NULL);
+  tt_assert(r != NULL);
 
   result =
     replaycache_add_and_test_internal(1200, r, test_buffer,
         strlen(test_buffer), NULL);
-  test_eq(result, 0);
+  tt_int_op(result,==, 0);
 
   result =
     replaycache_add_and_test_internal(1300, r, test_buffer,
         strlen(test_buffer), &elapsed);
-  test_eq(result, 1);
-  test_eq(elapsed, 100);
+  tt_int_op(result,==, 1);
+  tt_int_op(elapsed,==, 100);
 
  done:
   if (r) replaycache_free(r);
@@ -180,22 +180,22 @@ test_replaycache_noexpire(void)
   int result;
 
   r = replaycache_new(0, 0);
-  test_assert(r != NULL);
+  tt_assert(r != NULL);
 
   result =
     replaycache_add_and_test_internal(1200, r, test_buffer,
         strlen(test_buffer), NULL);
-  test_eq(result, 0);
+  tt_int_op(result,==, 0);
 
   result =
     replaycache_add_and_test_internal(1300, r, test_buffer,
         strlen(test_buffer), NULL);
-  test_eq(result, 1);
+  tt_int_op(result,==, 1);
 
   result =
     replaycache_add_and_test_internal(3000, r, test_buffer,
         strlen(test_buffer), NULL);
-  test_eq(result, 1);
+  tt_int_op(result,==, 1);
 
  done:
   if (r) replaycache_free(r);
@@ -210,18 +210,18 @@ test_replaycache_scrub(void)
   int result;
 
   r = replaycache_new(600, 300);
-  test_assert(r != NULL);
+  tt_assert(r != NULL);
 
   /* Set up like in test_replaycache_hit() */
   result =
     replaycache_add_and_test_internal(100, r, test_buffer,
         strlen(test_buffer), NULL);
-  test_eq(result, 0);
+  tt_int_op(result,==, 0);
 
   result =
     replaycache_add_and_test_internal(200, r, test_buffer,
         strlen(test_buffer), NULL);
-  test_eq(result, 1);
+  tt_int_op(result,==, 1);
 
   /*
    * Poke a few replaycache_scrub_if_needed_internal() error cases that
@@ -231,12 +231,12 @@ test_replaycache_scrub(void)
   /* Null cache */
   replaycache_scrub_if_needed_internal(300, NULL);
   /* Assert we're still here */
-  test_assert(1);
+  tt_assert(1);
 
   /* Make sure we hit the aging-out case too */
   replaycache_scrub_if_needed_internal(1500, r);
   /* Assert that we aged it */
-  test_eq(digestmap_size(r->digests_seen), 0);
+  tt_int_op(digestmap_size(r->digests_seen),==, 0);
 
  done:
   if (r) replaycache_free(r);
@@ -252,22 +252,22 @@ test_replaycache_future(void)
   time_t elapsed = 0;
 
   r = replaycache_new(600, 300);
-  test_assert(r != NULL);
+  tt_assert(r != NULL);
 
   /* Set up like in test_replaycache_hit() */
   result =
     replaycache_add_and_test_internal(100, r, test_buffer,
         strlen(test_buffer), &elapsed);
-  test_eq(result, 0);
+  tt_int_op(result,==, 0);
   /* elapsed should still be 0, since it wasn't written */
-  test_eq(elapsed, 0);
+  tt_int_op(elapsed,==, 0);
 
   result =
     replaycache_add_and_test_internal(200, r, test_buffer,
         strlen(test_buffer), &elapsed);
-  test_eq(result, 1);
+  tt_int_op(result,==, 1);
   /* elapsed should be the time since the last hit */
-  test_eq(elapsed, 100);
+  tt_int_op(elapsed,==, 100);
 
   /*
    * Now let's turn the clock back to get coverage on the cache entry from the
@@ -277,9 +277,9 @@ test_replaycache_future(void)
     replaycache_add_and_test_internal(150, r, test_buffer,
         strlen(test_buffer), &elapsed);
   /* We should still get a hit */
-  test_eq(result, 1);
+  tt_int_op(result,==, 1);
   /* ...but it shouldn't let us see a negative elapsed time */
-  test_eq(elapsed, 0);
+  tt_int_op(elapsed,==, 0);
 
  done:
   if (r) replaycache_free(r);
@@ -300,25 +300,25 @@ test_replaycache_realtime(void)
 
   /* Test the realtime as well as *_internal() entry points */
   r = replaycache_new(600, 300);
-  test_assert(r != NULL);
+  tt_assert(r != NULL);
 
   /* This should miss */
   result =
     replaycache_add_and_test(r, test_buffer, strlen(test_buffer));
-  test_eq(result, 0);
+  tt_int_op(result,==, 0);
 
   /* This should hit */
   result =
     replaycache_add_and_test(r, test_buffer, strlen(test_buffer));
-  test_eq(result, 1);
+  tt_int_op(result,==, 1);
 
   /* This should hit and return a small elapsed time */
   result =
     replaycache_add_test_and_elapsed(r, test_buffer,
                                      strlen(test_buffer), &elapsed);
-  test_eq(result, 1);
-  test_assert(elapsed >= 0);
-  test_assert(elapsed <= 5);
+  tt_int_op(result,==, 1);
+  tt_assert(elapsed >= 0);
+  tt_assert(elapsed <= 5);
 
   /* Scrub it to exercise that entry point too */
   replaycache_scrub_if_needed(r);
diff --git a/src/test/test_socks.c b/src/test/test_socks.c
index 4ce61e068b..20f58ca92a 100644
--- a/src/test/test_socks.c
+++ b/src/test/test_socks.c
@@ -61,10 +61,10 @@ test_socks_4_unsupported_commands(void *ptr)
 
   /* SOCKS 4 Send BIND [02] to IP address 2.2.2.2:4369 */
   ADD_DATA(buf, "\x04\x02\x11\x11\x02\x02\x02\x02\x00");
-  test_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
+  tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
                                    get_options()->SafeSocks) == -1);
-  test_eq(4, socks->socks_version);
-  test_eq(0, socks->replylen); /* XXX: shouldn't tor reply? */
+  tt_int_op(4,==, socks->socks_version);
+  tt_int_op(0,==, socks->replylen); /* XXX: shouldn't tor reply? */
 
  done:
   ;
@@ -76,49 +76,49 @@ test_socks_4_supported_commands(void *ptr)
 {
   SOCKS_TEST_INIT();
 
-  test_eq(0, buf_datalen(buf));
+  tt_int_op(0,==, buf_datalen(buf));
 
   /* SOCKS 4 Send CONNECT [01] to IP address 2.2.2.2:4370 */
   ADD_DATA(buf, "\x04\x01\x11\x12\x02\x02\x02\x03\x00");
-  test_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
+  tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
                                    get_options()->SafeSocks) == 1);
-  test_eq(4, socks->socks_version);
-  test_eq(0, socks->replylen); /* XXX: shouldn't tor reply? */
-  test_eq(SOCKS_COMMAND_CONNECT, socks->command);
-  test_streq("2.2.2.3", socks->address);
-  test_eq(4370, socks->port);
-  test_assert(socks->got_auth == 0);
-  test_assert(! socks->username);
+  tt_int_op(4,==, socks->socks_version);
+  tt_int_op(0,==, socks->replylen); /* XXX: shouldn't tor reply? */
+  tt_int_op(SOCKS_COMMAND_CONNECT,==, socks->command);
+  tt_str_op("2.2.2.3",==, socks->address);
+  tt_int_op(4370,==, socks->port);
+  tt_assert(socks->got_auth == 0);
+  tt_assert(! socks->username);
 
-  test_eq(0, buf_datalen(buf));
+  tt_int_op(0,==, buf_datalen(buf));
   socks_request_clear(socks);
 
   /* SOCKS 4 Send CONNECT [01] to IP address 2.2.2.2:4369 with userid*/
   ADD_DATA(buf, "\x04\x01\x11\x12\x02\x02\x02\x04me\x00");
-  test_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
+  tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
                                    get_options()->SafeSocks) == 1);
-  test_eq(4, socks->socks_version);
-  test_eq(0, socks->replylen); /* XXX: shouldn't tor reply? */
-  test_eq(SOCKS_COMMAND_CONNECT, socks->command);
-  test_streq("2.2.2.4", socks->address);
-  test_eq(4370, socks->port);
-  test_assert(socks->got_auth == 1);
-  test_assert(socks->username);
-  test_eq(2, socks->usernamelen);
-  test_memeq("me", socks->username, 2);
+  tt_int_op(4,==, socks->socks_version);
+  tt_int_op(0,==, socks->replylen); /* XXX: shouldn't tor reply? */
+  tt_int_op(SOCKS_COMMAND_CONNECT,==, socks->command);
+  tt_str_op("2.2.2.4",==, socks->address);
+  tt_int_op(4370,==, socks->port);
+  tt_assert(socks->got_auth == 1);
+  tt_assert(socks->username);
+  tt_int_op(2,==, socks->usernamelen);
+  tt_mem_op("me",==, socks->username, 2);
 
-  test_eq(0, buf_datalen(buf));
+  tt_int_op(0,==, buf_datalen(buf));
   socks_request_clear(socks);
 
   /* SOCKS 4a Send RESOLVE [F0] request for torproject.org */
   ADD_DATA(buf, "\x04\xF0\x01\x01\x00\x00\x00\x02me\x00torproject.org\x00");
-  test_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
+  tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
                                    get_options()->SafeSocks) == 1);
-  test_eq(4, socks->socks_version);
-  test_eq(0, socks->replylen); /* XXX: shouldn't tor reply? */
-  test_streq("torproject.org", socks->address);
+  tt_int_op(4,==, socks->socks_version);
+  tt_int_op(0,==, socks->replylen); /* XXX: shouldn't tor reply? */
+  tt_str_op("torproject.org",==, socks->address);
 
-  test_eq(0, buf_datalen(buf));
+  tt_int_op(0,==, buf_datalen(buf));
 
  done:
   ;
@@ -133,16 +133,16 @@ test_socks_5_unsupported_commands(void *ptr)
   /* SOCKS 5 Send unsupported BIND [02] command */
   ADD_DATA(buf, "\x05\x02\x00\x01");
 
-  test_eq(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
-                               get_options()->SafeSocks), 0);
-  test_eq(0, buf_datalen(buf));
-  test_eq(5, socks->socks_version);
-  test_eq(2, socks->replylen);
-  test_eq(5, socks->reply[0]);
-  test_eq(0, socks->reply[1]);
+  tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
+                               get_options()->SafeSocks),==, 0);
+  tt_int_op(0,==, buf_datalen(buf));
+  tt_int_op(5,==, socks->socks_version);
+  tt_int_op(2,==, socks->replylen);
+  tt_int_op(5,==, socks->reply[0]);
+  tt_int_op(0,==, socks->reply[1]);
   ADD_DATA(buf, "\x05\x02\x00\x01\x02\x02\x02\x01\x01\x01");
-  test_eq(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
-                               get_options()->SafeSocks), -1);
+  tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
+                               get_options()->SafeSocks),==, -1);
   /* XXX: shouldn't tor reply 'command not supported' [07]? */
 
   buf_clear(buf);
@@ -150,15 +150,15 @@ test_socks_5_unsupported_commands(void *ptr)
 
   /* SOCKS 5 Send unsupported UDP_ASSOCIATE [03] command */
   ADD_DATA(buf, "\x05\x03\x00\x01\x02");
-  test_eq(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
-                               get_options()->SafeSocks), 0);
-  test_eq(5, socks->socks_version);
-  test_eq(2, socks->replylen);
-  test_eq(5, socks->reply[0]);
-  test_eq(2, socks->reply[1]);
+  tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
+                               get_options()->SafeSocks),==, 0);
+  tt_int_op(5,==, socks->socks_version);
+  tt_int_op(2,==, socks->replylen);
+  tt_int_op(5,==, socks->reply[0]);
+  tt_int_op(2,==, socks->reply[1]);
   ADD_DATA(buf, "\x05\x03\x00\x01\x02\x02\x02\x01\x01\x01");
-  test_eq(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
-                               get_options()->SafeSocks), -1);
+  tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
+                               get_options()->SafeSocks),==, -1);
   /* XXX: shouldn't tor reply 'command not supported' [07]? */
 
  done:
@@ -173,64 +173,64 @@ test_socks_5_supported_commands(void *ptr)
 
   /* SOCKS 5 Send CONNECT [01] to IP address 2.2.2.2:4369 */
   ADD_DATA(buf, "\x05\x01\x00");
-  test_eq(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
-                                   get_options()->SafeSocks), 0);
-  test_eq(5, socks->socks_version);
-  test_eq(2, socks->replylen);
-  test_eq(5, socks->reply[0]);
-  test_eq(0, socks->reply[1]);
+  tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
+                                   get_options()->SafeSocks),==, 0);
+  tt_int_op(5,==, socks->socks_version);
+  tt_int_op(2,==, socks->replylen);
+  tt_int_op(5,==, socks->reply[0]);
+  tt_int_op(0,==, socks->reply[1]);
 
   ADD_DATA(buf, "\x05\x01\x00\x01\x02\x02\x02\x02\x11\x11");
-  test_eq(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
-                                   get_options()->SafeSocks), 1);
-  test_streq("2.2.2.2", socks->address);
-  test_eq(4369, socks->port);
+  tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
+                                   get_options()->SafeSocks),==, 1);
+  tt_str_op("2.2.2.2",==, socks->address);
+  tt_int_op(4369,==, socks->port);
 
-  test_eq(0, buf_datalen(buf));
+  tt_int_op(0,==, buf_datalen(buf));
   socks_request_clear(socks);
 
   /* SOCKS 5 Send CONNECT [01] to FQDN torproject.org:4369 */
   ADD_DATA(buf, "\x05\x01\x00");
   ADD_DATA(buf, "\x05\x01\x00\x03\x0Etorproject.org\x11\x11");
-  test_eq(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
-                                   get_options()->SafeSocks), 1);
+  tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
+                                   get_options()->SafeSocks),==, 1);
 
-  test_eq(5, socks->socks_version);
-  test_eq(2, socks->replylen);
-  test_eq(5, socks->reply[0]);
-  test_eq(0, socks->reply[1]);
-  test_streq("torproject.org", socks->address);
-  test_eq(4369, socks->port);
+  tt_int_op(5,==, socks->socks_version);
+  tt_int_op(2,==, socks->replylen);
+  tt_int_op(5,==, socks->reply[0]);
+  tt_int_op(0,==, socks->reply[1]);
+  tt_str_op("torproject.org",==, socks->address);
+  tt_int_op(4369,==, socks->port);
 
-  test_eq(0, buf_datalen(buf));
+  tt_int_op(0,==, buf_datalen(buf));
   socks_request_clear(socks);
 
   /* SOCKS 5 Send RESOLVE [F0] request for torproject.org:4369 */
   ADD_DATA(buf, "\x05\x01\x00");
   ADD_DATA(buf, "\x05\xF0\x00\x03\x0Etorproject.org\x01\x02");
-  test_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
+  tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
                                    get_options()->SafeSocks) == 1);
-  test_eq(5, socks->socks_version);
-  test_eq(2, socks->replylen);
-  test_eq(5, socks->reply[0]);
-  test_eq(0, socks->reply[1]);
-  test_streq("torproject.org", socks->address);
+  tt_int_op(5,==, socks->socks_version);
+  tt_int_op(2,==, socks->replylen);
+  tt_int_op(5,==, socks->reply[0]);
+  tt_int_op(0,==, socks->reply[1]);
+  tt_str_op("torproject.org",==, socks->address);
 
-  test_eq(0, buf_datalen(buf));
+  tt_int_op(0,==, buf_datalen(buf));
   socks_request_clear(socks);
 
   /* SOCKS 5 Send RESOLVE_PTR [F1] for IP address 2.2.2.5 */
   ADD_DATA(buf, "\x05\x01\x00");
   ADD_DATA(buf, "\x05\xF1\x00\x01\x02\x02\x02\x05\x01\x03");
-  test_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
+  tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
                                    get_options()->SafeSocks) == 1);
-  test_eq(5, socks->socks_version);
-  test_eq(2, socks->replylen);
-  test_eq(5, socks->reply[0]);
-  test_eq(0, socks->reply[1]);
-  test_streq("2.2.2.5", socks->address);
+  tt_int_op(5,==, socks->socks_version);
+  tt_int_op(2,==, socks->replylen);
+  tt_int_op(5,==, socks->reply[0]);
+  tt_int_op(0,==, socks->reply[1]);
+  tt_str_op("2.2.2.5",==, socks->address);
 
-  test_eq(0, buf_datalen(buf));
+  tt_int_op(0,==, buf_datalen(buf));
 
  done:
   ;
@@ -244,30 +244,30 @@ test_socks_5_no_authenticate(void *ptr)
 
   /*SOCKS 5 No Authentication */
   ADD_DATA(buf,"\x05\x01\x00");
-  test_assert(!fetch_from_buf_socks(buf, socks,
+  tt_assert(!fetch_from_buf_socks(buf, socks,
                                     get_options()->TestSocks,
                                     get_options()->SafeSocks));
-  test_eq(2, socks->replylen);
-  test_eq(5, socks->reply[0]);
-  test_eq(SOCKS_NO_AUTH, socks->reply[1]);
+  tt_int_op(2,==, socks->replylen);
+  tt_int_op(5,==, socks->reply[0]);
+  tt_int_op(SOCKS_NO_AUTH,==, socks->reply[1]);
 
-  test_eq(0, buf_datalen(buf));
+  tt_int_op(0,==, buf_datalen(buf));
 
   /*SOCKS 5 Send username/password anyway - pretend to be broken */
   ADD_DATA(buf,"\x01\x02\x01\x01\x02\x01\x01");
-  test_assert(!fetch_from_buf_socks(buf, socks,
+  tt_assert(!fetch_from_buf_socks(buf, socks,
                                     get_options()->TestSocks,
                                     get_options()->SafeSocks));
-  test_eq(5, socks->socks_version);
-  test_eq(2, socks->replylen);
-  test_eq(1, socks->reply[0]);
-  test_eq(0, socks->reply[1]);
+  tt_int_op(5,==, socks->socks_version);
+  tt_int_op(2,==, socks->replylen);
+  tt_int_op(1,==, socks->reply[0]);
+  tt_int_op(0,==, socks->reply[1]);
 
-  test_eq(2, socks->usernamelen);
-  test_eq(2, socks->passwordlen);
+  tt_int_op(2,==, socks->usernamelen);
+  tt_int_op(2,==, socks->passwordlen);
 
-  test_memeq("\x01\x01", socks->username, 2);
-  test_memeq("\x01\x01", socks->password, 2);
+  tt_mem_op("\x01\x01",==, socks->username, 2);
+  tt_mem_op("\x01\x01",==, socks->password, 2);
 
  done:
   ;
@@ -282,31 +282,31 @@ test_socks_5_authenticate(void *ptr)
   /* SOCKS 5 Negotiate username/password authentication */
   ADD_DATA(buf, "\x05\x01\x02");
 
-  test_assert(!fetch_from_buf_socks(buf, socks,
+  tt_assert(!fetch_from_buf_socks(buf, socks,
                                    get_options()->TestSocks,
                                    get_options()->SafeSocks));
-  test_eq(2, socks->replylen);
-  test_eq(5, socks->reply[0]);
-  test_eq(SOCKS_USER_PASS, socks->reply[1]);
-  test_eq(5, socks->socks_version);
+  tt_int_op(2,==, socks->replylen);
+  tt_int_op(5,==, socks->reply[0]);
+  tt_int_op(SOCKS_USER_PASS,==, socks->reply[1]);
+  tt_int_op(5,==, socks->socks_version);
 
-  test_eq(0, buf_datalen(buf));
+  tt_int_op(0,==, buf_datalen(buf));
 
   /* SOCKS 5 Send username/password */
   ADD_DATA(buf, "\x01\x02me\x08mypasswd");
-  test_assert(!fetch_from_buf_socks(buf, socks,
+  tt_assert(!fetch_from_buf_socks(buf, socks,
                                    get_options()->TestSocks,
                                    get_options()->SafeSocks));
-  test_eq(5, socks->socks_version);
-  test_eq(2, socks->replylen);
-  test_eq(1, socks->reply[0]);
-  test_eq(0, socks->reply[1]);
+  tt_int_op(5,==, socks->socks_version);
+  tt_int_op(2,==, socks->replylen);
+  tt_int_op(1,==, socks->reply[0]);
+  tt_int_op(0,==, socks->reply[1]);
 
-  test_eq(2, socks->usernamelen);
-  test_eq(8, socks->passwordlen);
+  tt_int_op(2,==, socks->usernamelen);
+  tt_int_op(8,==, socks->passwordlen);
 
-  test_memeq("me", socks->username, 2);
-  test_memeq("mypasswd", socks->password, 8);
+  tt_mem_op("me",==, socks->username, 2);
+  tt_mem_op("mypasswd",==, socks->password, 8);
 
  done:
   ;
@@ -321,34 +321,34 @@ test_socks_5_authenticate_with_data(void *ptr)
   /* SOCKS 5 Negotiate username/password authentication */
   ADD_DATA(buf, "\x05\x01\x02");
 
-  test_assert(!fetch_from_buf_socks(buf, socks,
+  tt_assert(!fetch_from_buf_socks(buf, socks,
                                    get_options()->TestSocks,
                                    get_options()->SafeSocks));
-  test_eq(2, socks->replylen);
-  test_eq(5, socks->reply[0]);
-  test_eq(SOCKS_USER_PASS, socks->reply[1]);
-  test_eq(5, socks->socks_version);
+  tt_int_op(2,==, socks->replylen);
+  tt_int_op(5,==, socks->reply[0]);
+  tt_int_op(SOCKS_USER_PASS,==, socks->reply[1]);
+  tt_int_op(5,==, socks->socks_version);
 
-  test_eq(0, buf_datalen(buf));
+  tt_int_op(0,==, buf_datalen(buf));
 
   /* SOCKS 5 Send username/password */
   /* SOCKS 5 Send CONNECT [01] to IP address 2.2.2.2:4369 */
   ADD_DATA(buf, "\x01\x02me\x03you\x05\x01\x00\x01\x02\x02\x02\x02\x11\x11");
-  test_assert(fetch_from_buf_socks(buf, socks,
+  tt_assert(fetch_from_buf_socks(buf, socks,
                                    get_options()->TestSocks,
                                    get_options()->SafeSocks) == 1);
-  test_eq(5, socks->socks_version);
-  test_eq(2, socks->replylen);
-  test_eq(1, socks->reply[0]);
-  test_eq(0, socks->reply[1]);
+  tt_int_op(5,==, socks->socks_version);
+  tt_int_op(2,==, socks->replylen);
+  tt_int_op(1,==, socks->reply[0]);
+  tt_int_op(0,==, socks->reply[1]);
 
-  test_streq("2.2.2.2", socks->address);
-  test_eq(4369, socks->port);
+  tt_str_op("2.2.2.2",==, socks->address);
+  tt_int_op(4369,==, socks->port);
 
-  test_eq(2, socks->usernamelen);
-  test_eq(3, socks->passwordlen);
-  test_memeq("me", socks->username, 2);
-  test_memeq("you", socks->password, 3);
+  tt_int_op(2,==, socks->usernamelen);
+  tt_int_op(3,==, socks->passwordlen);
+  tt_mem_op("me",==, socks->username, 2);
+  tt_mem_op("you",==, socks->password, 3);
 
  done:
   ;
@@ -362,13 +362,13 @@ test_socks_5_auth_before_negotiation(void *ptr)
 
   /* SOCKS 5 Send username/password */
   ADD_DATA(buf, "\x01\x02me\x02me");
-  test_assert(fetch_from_buf_socks(buf, socks,
+  tt_assert(fetch_from_buf_socks(buf, socks,
                                    get_options()->TestSocks,
                                    get_options()->SafeSocks) == -1);
-  test_eq(0, socks->socks_version);
-  test_eq(0, socks->replylen);
-  test_eq(0, socks->reply[0]);
-  test_eq(0, socks->reply[1]);
+  tt_int_op(0,==, socks->socks_version);
+  tt_int_op(0,==, socks->replylen);
+  tt_int_op(0,==, socks->reply[0]);
+  tt_int_op(0,==, socks->reply[1]);
 
  done:
   ;
diff --git a/src/test/test_util.c b/src/test/test_util.c
index 962cb0e862..b819d5357b 100644
--- a/src/test/test_util.c
+++ b/src/test/test_util.c
@@ -64,8 +64,8 @@ test_util_read_until_eof_impl(const char *fname, size_t file_len,
   else
     tt_int_op(sz, ==, file_len);
 
-  test_mem_op(test_str, ==, str, sz);
-  test_assert(str[sz] == '\0');
+  tt_mem_op(test_str, ==, str, sz);
+  tt_int_op(str[sz], ==, '\0');
 
  done:
   unlink(fifo_name);
@@ -177,7 +177,7 @@ test_util_write_chunks_to_file(void *arg)
   str = read_file_to_str(fname, RFTS_BIN, &st);
   tt_assert(str != NULL);
   tt_u64_op((uint64_t)st.st_size, ==, data_str_len);
-  test_mem_op(data_str, ==, str, data_str_len);
+  tt_mem_op(data_str, ==, str, data_str_len);
   tor_free(str);
 
   // assert that the tempfile is removed (should not leave artifacts)
@@ -208,14 +208,14 @@ test_util_write_chunks_to_file(void *arg)
   str = read_file_to_str(fname, RFTS_BIN, &st);
   tt_assert(str != NULL);
   tt_u64_op((uint64_t)st.st_size, ==, data_str_len);
-  test_mem_op(data_str, ==, str, data_str_len);
+  tt_mem_op(data_str, ==, str, data_str_len);
   tor_free(str);
 
   // assert the tempfile still contains the known string
   str = read_file_to_str(tempname, RFTS_BIN, &st);
   tt_assert(str != NULL);
   tt_u64_op((uint64_t)st.st_size, ==, temp_str_len);
-  test_mem_op(temp_str, ==, str, temp_str_len);
+  tt_mem_op(temp_str, ==, str, temp_str_len);
 
  done:
   unlink(fname);
@@ -246,23 +246,23 @@ test_util_time(void)
   end.tv_sec = 5;
   end.tv_usec = 5000;
 
-  test_eq(0L, tv_udiff(&start, &end));
+  tt_int_op(0L,==, tv_udiff(&start, &end));
 
   end.tv_usec = 7000;
 
-  test_eq(2000L, tv_udiff(&start, &end));
+  tt_int_op(2000L,==, tv_udiff(&start, &end));
 
   end.tv_sec = 6;
 
-  test_eq(1002000L, tv_udiff(&start, &end));
+  tt_int_op(1002000L,==, tv_udiff(&start, &end));
 
   end.tv_usec = 0;
 
-  test_eq(995000L, tv_udiff(&start, &end));
+  tt_int_op(995000L,==, tv_udiff(&start, &end));
 
   end.tv_sec = 4;
 
-  test_eq(-1005000L, tv_udiff(&start, &end));
+  tt_int_op(-1005000L,==, tv_udiff(&start, &end));
 
   /* Test tor_timegm */
 
@@ -274,45 +274,45 @@ test_util_time(void)
   a_time.tm_hour = 6;
   a_time.tm_min = 14;
   a_time.tm_sec = 55;
-  test_eq((time_t) 1062224095UL, tor_timegm(&a_time));
+  tt_int_op((time_t) 1062224095UL,==, tor_timegm(&a_time));
   a_time.tm_year = 2004-1900; /* Try a leap year, after feb. */
-  test_eq((time_t) 1093846495UL, tor_timegm(&a_time));
+  tt_int_op((time_t) 1093846495UL,==, tor_timegm(&a_time));
   a_time.tm_mon = 1;          /* Try a leap year, in feb. */
   a_time.tm_mday = 10;
-  test_eq((time_t) 1076393695UL, tor_timegm(&a_time));
+  tt_int_op((time_t) 1076393695UL,==, tor_timegm(&a_time));
   a_time.tm_mon = 0;
   a_time.tm_mday = 10;
-  test_eq((time_t) 1073715295UL, tor_timegm(&a_time));
+  tt_int_op((time_t) 1073715295UL,==, tor_timegm(&a_time));
   a_time.tm_mon = 12;          /* Wrong month, it's 0-based */
   a_time.tm_mday = 10;
-  test_eq((time_t) -1, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
   a_time.tm_mon = -1;          /* Wrong month */
   a_time.tm_mday = 10;
-  test_eq((time_t) -1, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
 
   /* Test {format,parse}_rfc1123_time */
 
   format_rfc1123_time(timestr, 0);
-  test_streq("Thu, 01 Jan 1970 00:00:00 GMT", timestr);
+  tt_str_op("Thu, 01 Jan 1970 00:00:00 GMT",==, timestr);
   format_rfc1123_time(timestr, (time_t)1091580502UL);
-  test_streq("Wed, 04 Aug 2004 00:48:22 GMT", timestr);
+  tt_str_op("Wed, 04 Aug 2004 00:48:22 GMT",==, timestr);
 
   t_res = 0;
   i = parse_rfc1123_time(timestr, &t_res);
-  test_eq(0,i);
-  test_eq(t_res, (time_t)1091580502UL);
+  tt_int_op(0,==, i);
+  tt_int_op(t_res,==, (time_t)1091580502UL);
   /* The timezone doesn't matter */
   t_res = 0;
-  test_eq(0, parse_rfc1123_time("Wed, 04 Aug 2004 00:48:22 ZUL", &t_res));
-  test_eq(t_res, (time_t)1091580502UL);
-  test_eq(-1, parse_rfc1123_time("Wed, zz Aug 2004 99-99x99 GMT", &t_res));
-  test_eq(-1, parse_rfc1123_time("Wed, 32 Mar 2011 00:00:00 GMT", &t_res));
-  test_eq(-1, parse_rfc1123_time("Wed, 30 Mar 2011 24:00:00 GMT", &t_res));
-  test_eq(-1, parse_rfc1123_time("Wed, 30 Mar 2011 23:60:00 GMT", &t_res));
-  test_eq(-1, parse_rfc1123_time("Wed, 30 Mar 2011 23:59:62 GMT", &t_res));
-  test_eq(-1, parse_rfc1123_time("Wed, 30 Mar 1969 23:59:59 GMT", &t_res));
-  test_eq(-1, parse_rfc1123_time("Wed, 30 Ene 2011 23:59:59 GMT", &t_res));
-  test_eq(-1, parse_rfc1123_time("Wed, 30 Mar 2011 23:59:59 GM", &t_res));
+  tt_int_op(0,==, parse_rfc1123_time("Wed, 04 Aug 2004 00:48:22 ZUL", &t_res));
+  tt_int_op(t_res,==, (time_t)1091580502UL);
+  tt_int_op(-1,==, parse_rfc1123_time("Wed, zz Aug 2004 99-99x99 GMT", &t_res));
+  tt_int_op(-1,==, parse_rfc1123_time("Wed, 32 Mar 2011 00:00:00 GMT", &t_res));
+  tt_int_op(-1,==, parse_rfc1123_time("Wed, 30 Mar 2011 24:00:00 GMT", &t_res));
+  tt_int_op(-1,==, parse_rfc1123_time("Wed, 30 Mar 2011 23:60:00 GMT", &t_res));
+  tt_int_op(-1,==, parse_rfc1123_time("Wed, 30 Mar 2011 23:59:62 GMT", &t_res));
+  tt_int_op(-1,==, parse_rfc1123_time("Wed, 30 Mar 1969 23:59:59 GMT", &t_res));
+  tt_int_op(-1,==, parse_rfc1123_time("Wed, 30 Ene 2011 23:59:59 GMT", &t_res));
+  tt_int_op(-1,==, parse_rfc1123_time("Wed, 30 Mar 2011 23:59:59 GM", &t_res));
 
 #if 0
   /* This fails, I imagine it's important and should be fixed? */
@@ -326,31 +326,31 @@ test_util_time(void)
 
   t_res = 0;
   i = parse_iso_time("", &t_res);
-  test_eq(-1, i);
+  tt_int_op(-1,==, i);
   t_res = 0;
   i = parse_iso_time("2004-08-32 00:48:22", &t_res);
-  test_eq(-1, i);
+  tt_int_op(-1,==, i);
   t_res = 0;
   i = parse_iso_time("1969-08-03 00:48:22", &t_res);
-  test_eq(-1, i);
+  tt_int_op(-1,==, i);
 
   t_res = 0;
   i = parse_iso_time("2004-08-04 00:48:22", &t_res);
-  test_eq(0,i);
-  test_eq(t_res, (time_t)1091580502UL);
+  tt_int_op(0,==, i);
+  tt_int_op(t_res,==, (time_t)1091580502UL);
   t_res = 0;
   i = parse_iso_time("2004-8-4 0:48:22", &t_res);
-  test_eq(0, i);
-  test_eq(t_res, (time_t)1091580502UL);
-  test_eq(-1, parse_iso_time("2004-08-zz 99-99x99 GMT", &t_res));
-  test_eq(-1, parse_iso_time("2011-03-32 00:00:00 GMT", &t_res));
-  test_eq(-1, parse_iso_time("2011-03-30 24:00:00 GMT", &t_res));
-  test_eq(-1, parse_iso_time("2011-03-30 23:60:00 GMT", &t_res));
-  test_eq(-1, parse_iso_time("2011-03-30 23:59:62 GMT", &t_res));
-  test_eq(-1, parse_iso_time("1969-03-30 23:59:59 GMT", &t_res));
-  test_eq(-1, parse_iso_time("2011-00-30 23:59:59 GMT", &t_res));
-  test_eq(-1, parse_iso_time("2147483647-08-29 14:00:00", &t_res));
-  test_eq(-1, parse_iso_time("2011-03-30 23:59", &t_res));
+  tt_int_op(0,==, i);
+  tt_int_op(t_res,==, (time_t)1091580502UL);
+  tt_int_op(-1,==, parse_iso_time("2004-08-zz 99-99x99 GMT", &t_res));
+  tt_int_op(-1,==, parse_iso_time("2011-03-32 00:00:00 GMT", &t_res));
+  tt_int_op(-1,==, parse_iso_time("2011-03-30 24:00:00 GMT", &t_res));
+  tt_int_op(-1,==, parse_iso_time("2011-03-30 23:60:00 GMT", &t_res));
+  tt_int_op(-1,==, parse_iso_time("2011-03-30 23:59:62 GMT", &t_res));
+  tt_int_op(-1,==, parse_iso_time("1969-03-30 23:59:59 GMT", &t_res));
+  tt_int_op(-1,==, parse_iso_time("2011-00-30 23:59:59 GMT", &t_res));
+  tt_int_op(-1,==, parse_iso_time("2147483647-08-29 14:00:00", &t_res));
+  tt_int_op(-1,==, parse_iso_time("2011-03-30 23:59", &t_res));
 
   /* Test tor_gettimeofday */
 
@@ -370,7 +370,7 @@ test_util_time(void)
   tv.tv_sec = (time_t)1326296338;
   tv.tv_usec = 3060;
   format_iso_time(timestr, (time_t)tv.tv_sec);
-  test_streq("2012-01-11 15:38:58", timestr);
+  tt_str_op("2012-01-11 15:38:58",==, timestr);
   /* The output of format_local_iso_time will vary by timezone, and setting
      our timezone for testing purposes would be a nontrivial flaky pain.
      Skip this test for now.
@@ -378,11 +378,11 @@ test_util_time(void)
   test_streq("2012-01-11 10:38:58", timestr);
   */
   format_iso_time_nospace(timestr, (time_t)tv.tv_sec);
-  test_streq("2012-01-11T15:38:58", timestr);
-  test_eq(strlen(timestr), ISO_TIME_LEN);
+  tt_str_op("2012-01-11T15:38:58",==, timestr);
+  tt_int_op(strlen(timestr),==, ISO_TIME_LEN);
   format_iso_time_nospace_usec(timestr, &tv);
-  test_streq("2012-01-11T15:38:58.003060", timestr);
-  test_eq(strlen(timestr), ISO_TIME_USEC_LEN);
+  tt_str_op("2012-01-11T15:38:58.003060",==, timestr);
+  tt_int_op(strlen(timestr),==, ISO_TIME_USEC_LEN);
 
  done:
   ;
@@ -403,55 +403,55 @@ test_util_parse_http_time(void *arg)
 
   /* Test parse_http_time */
 
-  test_eq(-1, parse_http_time("", &a_time));
-  test_eq(-1, parse_http_time("Sunday, 32 Aug 2004 00:48:22 GMT", &a_time));
-  test_eq(-1, parse_http_time("Sunday, 3 Aug 1869 00:48:22 GMT", &a_time));
-  test_eq(-1, parse_http_time("Sunday, 32-Aug-94 00:48:22 GMT", &a_time));
-  test_eq(-1, parse_http_time("Sunday, 3-Ago-04 00:48:22", &a_time));
-  test_eq(-1, parse_http_time("Sunday, August the third", &a_time));
-  test_eq(-1, parse_http_time("Wednesday,,04 Aug 1994 00:48:22 GMT", &a_time));
+  tt_int_op(-1,==, parse_http_time("", &a_time));
+  tt_int_op(-1,==, parse_http_time("Sunday, 32 Aug 2004 00:48:22 GMT", &a_time));
+  tt_int_op(-1,==, parse_http_time("Sunday, 3 Aug 1869 00:48:22 GMT", &a_time));
+  tt_int_op(-1,==, parse_http_time("Sunday, 32-Aug-94 00:48:22 GMT", &a_time));
+  tt_int_op(-1,==, parse_http_time("Sunday, 3-Ago-04 00:48:22", &a_time));
+  tt_int_op(-1,==, parse_http_time("Sunday, August the third", &a_time));
+  tt_int_op(-1,==, parse_http_time("Wednesday,,04 Aug 1994 00:48:22 GMT", &a_time));
 
-  test_eq(0, parse_http_time("Wednesday, 04 Aug 1994 00:48:22 GMT", &a_time));
-  test_eq((time_t)775961302UL, tor_timegm(&a_time));
+  tt_int_op(0,==, parse_http_time("Wednesday, 04 Aug 1994 00:48:22 GMT", &a_time));
+  tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  test_eq(0, parse_http_time("Wednesday, 4 Aug 1994 0:48:22 GMT", &a_time));
-  test_eq((time_t)775961302UL, tor_timegm(&a_time));
+  tt_int_op(0,==, parse_http_time("Wednesday, 4 Aug 1994 0:48:22 GMT", &a_time));
+  tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  test_eq(0, parse_http_time("Miercoles, 4 Aug 1994 0:48:22 GMT", &a_time));
-  test_eq((time_t)775961302UL, tor_timegm(&a_time));
+  tt_int_op(0,==, parse_http_time("Miercoles, 4 Aug 1994 0:48:22 GMT", &a_time));
+  tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  test_eq(0, parse_http_time("Wednesday, 04-Aug-94 00:48:22 GMT", &a_time));
-  test_eq((time_t)775961302UL, tor_timegm(&a_time));
+  tt_int_op(0,==, parse_http_time("Wednesday, 04-Aug-94 00:48:22 GMT", &a_time));
+  tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  test_eq(0, parse_http_time("Wednesday, 4-Aug-94 0:48:22 GMT", &a_time));
-  test_eq((time_t)775961302UL, tor_timegm(&a_time));
+  tt_int_op(0,==, parse_http_time("Wednesday, 4-Aug-94 0:48:22 GMT", &a_time));
+  tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  test_eq(0, parse_http_time("Miercoles, 4-Aug-94 0:48:22 GMT", &a_time));
-  test_eq((time_t)775961302UL, tor_timegm(&a_time));
+  tt_int_op(0,==, parse_http_time("Miercoles, 4-Aug-94 0:48:22 GMT", &a_time));
+  tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  test_eq(0, parse_http_time("Wed Aug 04 00:48:22 1994", &a_time));
-  test_eq((time_t)775961302UL, tor_timegm(&a_time));
+  tt_int_op(0,==, parse_http_time("Wed Aug 04 00:48:22 1994", &a_time));
+  tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  test_eq(0, parse_http_time("Wed Aug 4 0:48:22 1994", &a_time));
-  test_eq((time_t)775961302UL, tor_timegm(&a_time));
+  tt_int_op(0,==, parse_http_time("Wed Aug 4 0:48:22 1994", &a_time));
+  tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  test_eq(0, parse_http_time("Mie Aug 4 0:48:22 1994", &a_time));
-  test_eq((time_t)775961302UL, tor_timegm(&a_time));
+  tt_int_op(0,==, parse_http_time("Mie Aug 4 0:48:22 1994", &a_time));
+  tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  test_eq(0, parse_http_time("Sun, 1 Jan 2012 00:00:00 GMT", &a_time));
-  test_eq((time_t)1325376000UL, tor_timegm(&a_time));
+  tt_int_op(0,==, parse_http_time("Sun, 1 Jan 2012 00:00:00 GMT", &a_time));
+  tt_int_op((time_t)1325376000UL,==, tor_timegm(&a_time));
   T("2012-01-01 00:00:00");
-  test_eq(0, parse_http_time("Mon, 31 Dec 2012 00:00:00 GMT", &a_time));
-  test_eq((time_t)1356912000UL, tor_timegm(&a_time));
+  tt_int_op(0,==, parse_http_time("Mon, 31 Dec 2012 00:00:00 GMT", &a_time));
+  tt_int_op((time_t)1356912000UL,==, tor_timegm(&a_time));
   T("2012-12-31 00:00:00");
-  test_eq(-1, parse_http_time("2004-08-zz 99-99x99 GMT", &a_time));
-  test_eq(-1, parse_http_time("2011-03-32 00:00:00 GMT", &a_time));
-  test_eq(-1, parse_http_time("2011-03-30 24:00:00 GMT", &a_time));
-  test_eq(-1, parse_http_time("2011-03-30 23:60:00 GMT", &a_time));
-  test_eq(-1, parse_http_time("2011-03-30 23:59:62 GMT", &a_time));
-  test_eq(-1, parse_http_time("1969-03-30 23:59:59 GMT", &a_time));
-  test_eq(-1, parse_http_time("2011-00-30 23:59:59 GMT", &a_time));
-  test_eq(-1, parse_http_time("2011-03-30 23:59", &a_time));
+  tt_int_op(-1,==, parse_http_time("2004-08-zz 99-99x99 GMT", &a_time));
+  tt_int_op(-1,==, parse_http_time("2011-03-32 00:00:00 GMT", &a_time));
+  tt_int_op(-1,==, parse_http_time("2011-03-30 24:00:00 GMT", &a_time));
+  tt_int_op(-1,==, parse_http_time("2011-03-30 23:60:00 GMT", &a_time));
+  tt_int_op(-1,==, parse_http_time("2011-03-30 23:59:62 GMT", &a_time));
+  tt_int_op(-1,==, parse_http_time("1969-03-30 23:59:59 GMT", &a_time));
+  tt_int_op(-1,==, parse_http_time("2011-00-30 23:59:59 GMT", &a_time));
+  tt_int_op(-1,==, parse_http_time("2011-03-30 23:59", &a_time));
 
 #undef T
  done:
@@ -485,110 +485,110 @@ test_util_config_line(void)
   str = buf;
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k");
-  test_streq(v, "v");
+  tt_str_op(k,==, "k");
+  tt_str_op(v,==, "v");
   tor_free(k); tor_free(v);
-  test_assert(!strcmpstart(str, "key    value with"));
+  tt_assert(!strcmpstart(str, "key    value with"));
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "key");
-  test_streq(v, "value with spaces");
+  tt_str_op(k,==, "key");
+  tt_str_op(v,==, "value with spaces");
   tor_free(k); tor_free(v);
-  test_assert(!strcmpstart(str, "keykey"));
+  tt_assert(!strcmpstart(str, "keykey"));
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "keykey");
-  test_streq(v, "val");
+  tt_str_op(k,==, "keykey");
+  tt_str_op(v,==, "val");
   tor_free(k); tor_free(v);
-  test_assert(!strcmpstart(str, "k2\n"));
+  tt_assert(!strcmpstart(str, "k2\n"));
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k2");
-  test_streq(v, "");
+  tt_str_op(k,==, "k2");
+  tt_str_op(v,==, "");
   tor_free(k); tor_free(v);
-  test_assert(!strcmpstart(str, "k3 \n"));
+  tt_assert(!strcmpstart(str, "k3 \n"));
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k3");
-  test_streq(v, "");
+  tt_str_op(k,==, "k3");
+  tt_str_op(v,==, "");
   tor_free(k); tor_free(v);
-  test_assert(!strcmpstart(str, "#comment"));
+  tt_assert(!strcmpstart(str, "#comment"));
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k4");
-  test_streq(v, "");
+  tt_str_op(k,==, "k4");
+  tt_str_op(v,==, "");
   tor_free(k); tor_free(v);
-  test_assert(!strcmpstart(str, "k5#abc"));
+  tt_assert(!strcmpstart(str, "k5#abc"));
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k5");
-  test_streq(v, "");
+  tt_str_op(k,==, "k5");
+  tt_str_op(v,==, "");
   tor_free(k); tor_free(v);
-  test_assert(!strcmpstart(str, "k6"));
+  tt_assert(!strcmpstart(str, "k6"));
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k6");
-  test_streq(v, "val");
+  tt_str_op(k,==, "k6");
+  tt_str_op(v,==, "val");
   tor_free(k); tor_free(v);
-  test_assert(!strcmpstart(str, "kseven"));
+  tt_assert(!strcmpstart(str, "kseven"));
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "kseven");
-  test_streq(v, "a quoted \'string");
+  tt_str_op(k,==, "kseven");
+  tt_str_op(v,==, "a quoted \'string");
   tor_free(k); tor_free(v);
-  test_assert(!strcmpstart(str, "k8 "));
+  tt_assert(!strcmpstart(str, "k8 "));
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k8");
-  test_streq(v, "a quoted\n\"str\\ing\t\x01\x01\x01\"");
+  tt_str_op(k,==, "k8");
+  tt_str_op(v,==, "a quoted\n\"str\\ing\t\x01\x01\x01\"");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k9");
-  test_streq(v, "a line that spans two lines.");
+  tt_str_op(k,==, "k9");
+  tt_str_op(v,==, "a line that spans two lines.");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k10");
-  test_streq(v, "more than one continuation");
+  tt_str_op(k,==, "k10");
+  tt_str_op(v,==, "more than one continuation");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k11");
-  test_streq(v, "continuation at the start");
+  tt_str_op(k,==, "k11");
+  tt_str_op(v,==, "continuation at the start");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k12");
-  test_streq(v, "line with a embedded");
+  tt_str_op(k,==, "k12");
+  tt_str_op(v,==, "line with a embedded");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k13");
-  test_streq(v, "continuation at the very start");
+  tt_str_op(k,==, "k13");
+  tt_str_op(v,==, "continuation at the very start");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k14");
-  test_streq(v, "a line that has a comment and" );
+  tt_str_op(k,==, "k14");
+  tt_str_op(v,==, "a line that has a comment and" );
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k15");
-  test_streq(v, "this should be the next new line");
+  tt_str_op(k,==, "k15");
+  tt_str_op(v,==, "this should be the next new line");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k16");
-  test_streq(v, "a line that has a comment and" );
+  tt_str_op(k,==, "k16");
+  tt_str_op(v,==, "a line that has a comment and" );
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k17");
-  test_streq(v, "this should be the next new line");
+  tt_str_op(k,==, "k17");
+  tt_str_op(v,==, "this should be the next new line");
   tor_free(k); tor_free(v);
 
-  test_streq(str, "");
+  tt_str_op(str,==, "");
 
  done:
   tor_free(k);
@@ -618,30 +618,30 @@ test_util_config_line_quotes(void)
   str = buf1;
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "kTrailingSpace");
-  test_streq(v, "quoted value");
+  tt_str_op(k,==, "kTrailingSpace");
+  tt_str_op(v,==, "quoted value");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_eq_ptr(str, NULL);
+  tt_ptr_op(str,==, NULL);
   tor_free(k); tor_free(v);
 
   str = buf2;
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_eq_ptr(str, NULL);
+  tt_ptr_op(str,==, NULL);
   tor_free(k); tor_free(v);
 
   str = buf3;
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_eq_ptr(str, NULL);
+  tt_ptr_op(str,==, NULL);
   tor_free(k); tor_free(v);
 
   str = buf4;
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_eq_ptr(str, NULL);
+  tt_ptr_op(str,==, NULL);
   tor_free(k); tor_free(v);
 
  done:
@@ -664,16 +664,16 @@ test_util_config_line_comment_character(void)
   str = buf;
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k1");
-  test_streq(v, "# in quotes");
+  tt_str_op(k,==, "k1");
+  tt_str_op(v,==, "# in quotes");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "k2");
-  test_streq(v, "some value");
+  tt_str_op(k,==, "k2");
+  tt_str_op(v,==, "some value");
   tor_free(k); tor_free(v);
 
-  test_streq(str, "k3 /home/user/myTorNetwork#2\n");
+  tt_str_op(str,==, "k3 /home/user/myTorNetwork#2\n");
 
 #if 0
   str = parse_config_line_from_str(str, &k, &v);
@@ -733,77 +733,77 @@ test_util_config_line_escaped_content(void)
   str = buf1;
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "HexadecimalLower");
-  test_streq(v, "*");
+  tt_str_op(k,==, "HexadecimalLower");
+  tt_str_op(v,==, "*");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "HexadecimalUpper");
-  test_streq(v, "*");
+  tt_str_op(k,==, "HexadecimalUpper");
+  tt_str_op(v,==, "*");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "HexadecimalUpperX");
-  test_streq(v, "*");
+  tt_str_op(k,==, "HexadecimalUpperX");
+  tt_str_op(v,==, "*");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "Octal");
-  test_streq(v, "*");
+  tt_str_op(k,==, "Octal");
+  tt_str_op(v,==, "*");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "Newline");
-  test_streq(v, "\n");
+  tt_str_op(k,==, "Newline");
+  tt_str_op(v,==, "\n");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "Tab");
-  test_streq(v, "\t");
+  tt_str_op(k,==, "Tab");
+  tt_str_op(v,==, "\t");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "CarriageReturn");
-  test_streq(v, "\r");
+  tt_str_op(k,==, "CarriageReturn");
+  tt_str_op(v,==, "\r");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "DoubleQuote");
-  test_streq(v, "\"");
+  tt_str_op(k,==, "DoubleQuote");
+  tt_str_op(v,==, "\"");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "SimpleQuote");
-  test_streq(v, "'");
+  tt_str_op(k,==, "SimpleQuote");
+  tt_str_op(v,==, "'");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "Backslash");
-  test_streq(v, "\\");
+  tt_str_op(k,==, "Backslash");
+  tt_str_op(v,==, "\\");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_streq(k, "Mix");
-  test_streq(v, "This is a \"star\":\t'*'\nAnd second line");
+  tt_str_op(k,==, "Mix");
+  tt_str_op(v,==, "This is a \"star\":\t'*'\nAnd second line");
   tor_free(k); tor_free(v);
-  test_streq(str, "");
+  tt_str_op(str,==, "");
 
   str = buf2;
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_eq_ptr(str, NULL);
+  tt_ptr_op(str,==, NULL);
   tor_free(k); tor_free(v);
 
   str = buf3;
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_eq_ptr(str, NULL);
+  tt_ptr_op(str,==, NULL);
   tor_free(k); tor_free(v);
 
   str = buf4;
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_eq_ptr(str, NULL);
+  tt_ptr_op(str,==, NULL);
   tor_free(k); tor_free(v);
 
 #if 0
@@ -817,7 +817,7 @@ test_util_config_line_escaped_content(void)
   str = buf6;
 
   str = parse_config_line_from_str(str, &k, &v);
-  test_eq_ptr(str, NULL);
+  tt_ptr_op(str,==, NULL);
   tor_free(k); tor_free(v);
 
  done:
@@ -834,39 +834,39 @@ test_util_expand_filename(void)
   setenv("HOME", "/home/itv", 1); /* For "internal test value" */
 
   str = expand_filename("");
-  test_streq("", str);
+  tt_str_op("",==, str);
   tor_free(str);
 
   str = expand_filename("/normal/path");
-  test_streq("/normal/path", str);
+  tt_str_op("/normal/path",==, str);
   tor_free(str);
 
   str = expand_filename("/normal/trailing/path/");
-  test_streq("/normal/trailing/path/", str);
+  tt_str_op("/normal/trailing/path/",==, str);
   tor_free(str);
 
   str = expand_filename("~");
-  test_streq("/home/itv/", str);
+  tt_str_op("/home/itv/",==, str);
   tor_free(str);
 
   str = expand_filename("$HOME/nodice");
-  test_streq("$HOME/nodice", str);
+  tt_str_op("$HOME/nodice",==, str);
   tor_free(str);
 
   str = expand_filename("~/");
-  test_streq("/home/itv/", str);
+  tt_str_op("/home/itv/",==, str);
   tor_free(str);
 
   str = expand_filename("~/foobarqux");
-  test_streq("/home/itv/foobarqux", str);
+  tt_str_op("/home/itv/foobarqux",==, str);
   tor_free(str);
 
   str = expand_filename("~/../../etc/passwd");
-  test_streq("/home/itv/../../etc/passwd", str);
+  tt_str_op("/home/itv/../../etc/passwd",==, str);
   tor_free(str);
 
   str = expand_filename("~/trailing/");
-  test_streq("/home/itv/trailing/", str);
+  tt_str_op("/home/itv/trailing/",==, str);
   tor_free(str);
   /* Ideally we'd test ~anotheruser, but that's shady to test (we'd
      have to somehow inject/fake the get_user_homedir call) */
@@ -875,15 +875,15 @@ test_util_expand_filename(void)
   setenv("HOME", "/home/itv/", 1);
 
   str = expand_filename("~");
-  test_streq("/home/itv/", str);
+  tt_str_op("/home/itv/",==, str);
   tor_free(str);
 
   str = expand_filename("~/");
-  test_streq("/home/itv/", str);
+  tt_str_op("/home/itv/",==, str);
   tor_free(str);
 
   str = expand_filename("~/foo");
-  test_streq("/home/itv/foo", str);
+  tt_str_op("/home/itv/foo",==, str);
   tor_free(str);
 
   /* Try with empty $HOME */
@@ -891,15 +891,15 @@ test_util_expand_filename(void)
   setenv("HOME", "", 1);
 
   str = expand_filename("~");
-  test_streq("/", str);
+  tt_str_op("/",==, str);
   tor_free(str);
 
   str = expand_filename("~/");
-  test_streq("/", str);
+  tt_str_op("/",==, str);
   tor_free(str);
 
   str = expand_filename("~/foobar");
-  test_streq("/foobar", str);
+  tt_str_op("/foobar",==, str);
   tor_free(str);
 
   /* Try with $HOME unset */
@@ -907,15 +907,15 @@ test_util_expand_filename(void)
   unsetenv("HOME");
 
   str = expand_filename("~");
-  test_streq("/", str);
+  tt_str_op("/",==, str);
   tor_free(str);
 
   str = expand_filename("~/");
-  test_streq("/", str);
+  tt_str_op("/",==, str);
   tor_free(str);
 
   str = expand_filename("~/foobar");
-  test_streq("/foobar", str);
+  tt_str_op("/foobar",==, str);
   tor_free(str);
 
  done:
@@ -931,31 +931,31 @@ test_util_escape_string_socks(void)
 
   /** Simple backslash escape. */
   escaped_string = tor_escape_str_for_pt_args("This is a backslash: \\",";\\");
-  test_assert(escaped_string);
-  test_streq(escaped_string, "This is a backslash: \\\\");
+  tt_assert(escaped_string);
+  tt_str_op(escaped_string,==, "This is a backslash: \\\\");
   tor_free(escaped_string);
 
   /** Simple semicolon escape. */
   escaped_string = tor_escape_str_for_pt_args("First rule:Do not use ;",";\\");
-  test_assert(escaped_string);
-  test_streq(escaped_string, "First rule:Do not use \\;");
+  tt_assert(escaped_string);
+  tt_str_op(escaped_string,==, "First rule:Do not use \\;");
   tor_free(escaped_string);
 
   /** Empty string. */
   escaped_string = tor_escape_str_for_pt_args("", ";\\");
-  test_assert(escaped_string);
-  test_streq(escaped_string, "");
+  tt_assert(escaped_string);
+  tt_str_op(escaped_string,==, "");
   tor_free(escaped_string);
 
   /** Escape all characters. */
   escaped_string = tor_escape_str_for_pt_args(";\\;\\", ";\\");
-  test_assert(escaped_string);
-  test_streq(escaped_string, "\\;\\\\\\;\\\\");
+  tt_assert(escaped_string);
+  tt_str_op(escaped_string,==, "\\;\\\\\\;\\\\");
   tor_free(escaped_string);
 
   escaped_string = tor_escape_str_for_pt_args(";", ";\\");
-  test_assert(escaped_string);
-  test_streq(escaped_string, "\\;");
+  tt_assert(escaped_string);
+  tt_str_op(escaped_string,==, "\\;");
   tor_free(escaped_string);
 
  done:
@@ -966,14 +966,14 @@ static void
 test_util_string_is_key_value(void *ptr)
 {
   (void)ptr;
-  test_assert(string_is_key_value(LOG_WARN, "key=value"));
-  test_assert(string_is_key_value(LOG_WARN, "k=v"));
-  test_assert(string_is_key_value(LOG_WARN, "key="));
-  test_assert(string_is_key_value(LOG_WARN, "x="));
-  test_assert(string_is_key_value(LOG_WARN, "xx="));
-  test_assert(!string_is_key_value(LOG_WARN, "=value"));
-  test_assert(!string_is_key_value(LOG_WARN, "=x"));
-  test_assert(!string_is_key_value(LOG_WARN, "="));
+  tt_assert(string_is_key_value(LOG_WARN, "key=value"));
+  tt_assert(string_is_key_value(LOG_WARN, "k=v"));
+  tt_assert(string_is_key_value(LOG_WARN, "key="));
+  tt_assert(string_is_key_value(LOG_WARN, "x="));
+  tt_assert(string_is_key_value(LOG_WARN, "xx="));
+  tt_assert(!string_is_key_value(LOG_WARN, "=value"));
+  tt_assert(!string_is_key_value(LOG_WARN, "=x"));
+  tt_assert(!string_is_key_value(LOG_WARN, "="));
 
   /* ??? */
   /* test_assert(!string_is_key_value(LOG_WARN, "===")); */
@@ -990,264 +990,264 @@ test_util_strmisc(void)
   char *cp, *cp_tmp = NULL;
 
   /* Test strl operations */
-  test_eq(5, strlcpy(buf, "Hello", 0));
-  test_eq(5, strlcpy(buf, "Hello", 10));
-  test_streq(buf, "Hello");
-  test_eq(5, strlcpy(buf, "Hello", 6));
-  test_streq(buf, "Hello");
-  test_eq(5, strlcpy(buf, "Hello", 5));
-  test_streq(buf, "Hell");
+  tt_int_op(5,==, strlcpy(buf, "Hello", 0));
+  tt_int_op(5,==, strlcpy(buf, "Hello", 10));
+  tt_str_op(buf,==, "Hello");
+  tt_int_op(5,==, strlcpy(buf, "Hello", 6));
+  tt_str_op(buf,==, "Hello");
+  tt_int_op(5,==, strlcpy(buf, "Hello", 5));
+  tt_str_op(buf,==, "Hell");
   strlcpy(buf, "Hello", sizeof(buf));
-  test_eq(10, strlcat(buf, "Hello", 5));
+  tt_int_op(10,==, strlcat(buf, "Hello", 5));
 
   /* Test strstrip() */
   strlcpy(buf, "Testing 1 2 3", sizeof(buf));
   tor_strstrip(buf, ",!");
-  test_streq(buf, "Testing 1 2 3");
+  tt_str_op(buf,==, "Testing 1 2 3");
   strlcpy(buf, "!Testing 1 2 3?", sizeof(buf));
   tor_strstrip(buf, "!? ");
-  test_streq(buf, "Testing123");
+  tt_str_op(buf,==, "Testing123");
   strlcpy(buf, "!!!Testing 1 2 3??", sizeof(buf));
   tor_strstrip(buf, "!? ");
-  test_streq(buf, "Testing123");
+  tt_str_op(buf,==, "Testing123");
 
   /* Test parse_long */
   /* Empty/zero input */
-  test_eq(0L, tor_parse_long("",10,0,100,&i,NULL));
-  test_eq(0, i);
-  test_eq(0L, tor_parse_long("0",10,0,100,&i,NULL));
-  test_eq(1, i);
+  tt_int_op(0L,==, tor_parse_long("",10,0,100,&i,NULL));
+  tt_int_op(0,==, i);
+  tt_int_op(0L,==, tor_parse_long("0",10,0,100,&i,NULL));
+  tt_int_op(1,==, i);
   /* Normal cases */
-  test_eq(10L, tor_parse_long("10",10,0,100,&i,NULL));
-  test_eq(1, i);
-  test_eq(10L, tor_parse_long("10",10,0,10,&i,NULL));
-  test_eq(1, i);
-  test_eq(10L, tor_parse_long("10",10,10,100,&i,NULL));
-  test_eq(1, i);
-  test_eq(-50L, tor_parse_long("-50",10,-100,100,&i,NULL));
-  test_eq(1, i);
-  test_eq(-50L, tor_parse_long("-50",10,-100,0,&i,NULL));
-  test_eq(1, i);
-  test_eq(-50L, tor_parse_long("-50",10,-50,0,&i,NULL));
-  test_eq(1, i);
+  tt_int_op(10L,==, tor_parse_long("10",10,0,100,&i,NULL));
+  tt_int_op(1,==, i);
+  tt_int_op(10L,==, tor_parse_long("10",10,0,10,&i,NULL));
+  tt_int_op(1,==, i);
+  tt_int_op(10L,==, tor_parse_long("10",10,10,100,&i,NULL));
+  tt_int_op(1,==, i);
+  tt_int_op(-50L,==, tor_parse_long("-50",10,-100,100,&i,NULL));
+  tt_int_op(1,==, i);
+  tt_int_op(-50L,==, tor_parse_long("-50",10,-100,0,&i,NULL));
+  tt_int_op(1,==, i);
+  tt_int_op(-50L,==, tor_parse_long("-50",10,-50,0,&i,NULL));
+  tt_int_op(1,==, i);
   /* Extra garbage */
-  test_eq(0L, tor_parse_long("10m",10,0,100,&i,NULL));
-  test_eq(0, i);
-  test_eq(0L, tor_parse_long("-50 plus garbage",10,-100,100,&i,NULL));
-  test_eq(0, i);
-  test_eq(10L, tor_parse_long("10m",10,0,100,&i,&cp));
-  test_eq(1, i);
-  test_streq(cp, "m");
-  test_eq(-50L, tor_parse_long("-50 plus garbage",10,-100,100,&i,&cp));
-  test_eq(1, i);
-  test_streq(cp, " plus garbage");
+  tt_int_op(0L,==, tor_parse_long("10m",10,0,100,&i,NULL));
+  tt_int_op(0,==, i);
+  tt_int_op(0L,==, tor_parse_long("-50 plus garbage",10,-100,100,&i,NULL));
+  tt_int_op(0,==, i);
+  tt_int_op(10L,==, tor_parse_long("10m",10,0,100,&i,&cp));
+  tt_int_op(1,==, i);
+  tt_str_op(cp,==, "m");
+  tt_int_op(-50L,==, tor_parse_long("-50 plus garbage",10,-100,100,&i,&cp));
+  tt_int_op(1,==, i);
+  tt_str_op(cp,==, " plus garbage");
   /* Out of bounds */
-  test_eq(0L,  tor_parse_long("10",10,50,100,&i,NULL));
-  test_eq(0, i);
-  test_eq(0L,   tor_parse_long("-50",10,0,100,&i,NULL));
-  test_eq(0, i);
+  tt_int_op(0L,==,  tor_parse_long("10",10,50,100,&i,NULL));
+  tt_int_op(0,==, i);
+  tt_int_op(0L,==,   tor_parse_long("-50",10,0,100,&i,NULL));
+  tt_int_op(0,==, i);
   /* Base different than 10 */
-  test_eq(2L,   tor_parse_long("10",2,0,100,NULL,NULL));
-  test_eq(0L,   tor_parse_long("2",2,0,100,NULL,NULL));
-  test_eq(0L,   tor_parse_long("10",-2,0,100,NULL,NULL));
-  test_eq(68284L, tor_parse_long("10abc",16,0,70000,NULL,NULL));
-  test_eq(68284L, tor_parse_long("10ABC",16,0,70000,NULL,NULL));
-  test_eq(0, tor_parse_long("10ABC",-1,0,70000,&i,NULL));
-  test_eq(i, 0);
+  tt_int_op(2L,==,   tor_parse_long("10",2,0,100,NULL,NULL));
+  tt_int_op(0L,==,   tor_parse_long("2",2,0,100,NULL,NULL));
+  tt_int_op(0L,==,   tor_parse_long("10",-2,0,100,NULL,NULL));
+  tt_int_op(68284L,==, tor_parse_long("10abc",16,0,70000,NULL,NULL));
+  tt_int_op(68284L,==, tor_parse_long("10ABC",16,0,70000,NULL,NULL));
+  tt_int_op(0,==, tor_parse_long("10ABC",-1,0,70000,&i,NULL));
+  tt_int_op(i,==, 0);
 
   /* Test parse_ulong */
-  test_eq(0UL, tor_parse_ulong("",10,0,100,NULL,NULL));
-  test_eq(0UL, tor_parse_ulong("0",10,0,100,NULL,NULL));
-  test_eq(10UL, tor_parse_ulong("10",10,0,100,NULL,NULL));
-  test_eq(0UL, tor_parse_ulong("10",10,50,100,NULL,NULL));
-  test_eq(10UL, tor_parse_ulong("10",10,0,10,NULL,NULL));
-  test_eq(10UL, tor_parse_ulong("10",10,10,100,NULL,NULL));
-  test_eq(0UL, tor_parse_ulong("8",8,0,100,NULL,NULL));
-  test_eq(50UL, tor_parse_ulong("50",10,50,100,NULL,NULL));
-  test_eq(0UL, tor_parse_ulong("-50",10,-100,100,NULL,NULL));
-  test_eq(0UL, tor_parse_ulong("50",-1,50,100,&i,NULL));
-  test_eq(0, i);
+  tt_int_op(0UL,==, tor_parse_ulong("",10,0,100,NULL,NULL));
+  tt_int_op(0UL,==, tor_parse_ulong("0",10,0,100,NULL,NULL));
+  tt_int_op(10UL,==, tor_parse_ulong("10",10,0,100,NULL,NULL));
+  tt_int_op(0UL,==, tor_parse_ulong("10",10,50,100,NULL,NULL));
+  tt_int_op(10UL,==, tor_parse_ulong("10",10,0,10,NULL,NULL));
+  tt_int_op(10UL,==, tor_parse_ulong("10",10,10,100,NULL,NULL));
+  tt_int_op(0UL,==, tor_parse_ulong("8",8,0,100,NULL,NULL));
+  tt_int_op(50UL,==, tor_parse_ulong("50",10,50,100,NULL,NULL));
+  tt_int_op(0UL,==, tor_parse_ulong("-50",10,-100,100,NULL,NULL));
+  tt_int_op(0UL,==, tor_parse_ulong("50",-1,50,100,&i,NULL));
+  tt_int_op(0,==, i);
 
   /* Test parse_uint64 */
-  test_assert(U64_LITERAL(10) == tor_parse_uint64("10 x",10,0,100, &i, &cp));
-  test_eq(1, i);
-  test_streq(cp, " x");
-  test_assert(U64_LITERAL(12345678901) ==
+  tt_assert(U64_LITERAL(10) == tor_parse_uint64("10 x",10,0,100, &i, &cp));
+  tt_int_op(1,==, i);
+  tt_str_op(cp,==, " x");
+  tt_assert(U64_LITERAL(12345678901) ==
               tor_parse_uint64("12345678901",10,0,UINT64_MAX, &i, &cp));
-  test_eq(1, i);
-  test_streq(cp, "");
-  test_assert(U64_LITERAL(0) ==
+  tt_int_op(1,==, i);
+  tt_str_op(cp,==, "");
+  tt_assert(U64_LITERAL(0) ==
               tor_parse_uint64("12345678901",10,500,INT32_MAX, &i, &cp));
-  test_eq(0, i);
-  test_assert(U64_LITERAL(0) ==
+  tt_int_op(0,==, i);
+  tt_assert(U64_LITERAL(0) ==
               tor_parse_uint64("123",-1,0,INT32_MAX, &i, &cp));
-  test_eq(0, i);
+  tt_int_op(0,==, i);
 
   {
   /* Test parse_double */
   double d = tor_parse_double("10", 0, UINT64_MAX,&i,NULL);
-  test_eq(1, i);
-  test_assert(DBL_TO_U64(d) == 10);
+  tt_int_op(1,==, i);
+  tt_assert(DBL_TO_U64(d) == 10);
   d = tor_parse_double("0", 0, UINT64_MAX,&i,NULL);
-  test_eq(1, i);
-  test_assert(DBL_TO_U64(d) == 0);
+  tt_int_op(1,==, i);
+  tt_assert(DBL_TO_U64(d) == 0);
   d = tor_parse_double(" ", 0, UINT64_MAX,&i,NULL);
-  test_eq(0, i);
+  tt_int_op(0,==, i);
   d = tor_parse_double(".0a", 0, UINT64_MAX,&i,NULL);
-  test_eq(0, i);
+  tt_int_op(0,==, i);
   d = tor_parse_double(".0a", 0, UINT64_MAX,&i,&cp);
-  test_eq(1, i);
+  tt_int_op(1,==, i);
   d = tor_parse_double("-.0", 0, UINT64_MAX,&i,NULL);
-  test_eq(1, i);
-  test_assert(DBL_TO_U64(d) == 0);
+  tt_int_op(1,==, i);
+  tt_assert(DBL_TO_U64(d) == 0);
   d = tor_parse_double("-10", -100.0, 100.0,&i,NULL);
-  test_eq(1, i);
-  test_eq(-10.0, d);
+  tt_int_op(1,==, i);
+  tt_int_op(-10.0,==, d);
   }
 
   {
     /* Test tor_parse_* where we overflow/underflow the underlying type. */
     /* This string should overflow 64-bit ints. */
 #define TOOBIG "100000000000000000000000000"
-    test_eq(0L, tor_parse_long(TOOBIG, 10, LONG_MIN, LONG_MAX, &i, NULL));
-    test_eq(i, 0);
-    test_eq(0L, tor_parse_long("-"TOOBIG, 10, LONG_MIN, LONG_MAX, &i, NULL));
-    test_eq(i, 0);
-    test_eq(0UL, tor_parse_ulong(TOOBIG, 10, 0, ULONG_MAX, &i, NULL));
-    test_eq(i, 0);
+    tt_int_op(0L,==, tor_parse_long(TOOBIG, 10, LONG_MIN, LONG_MAX, &i, NULL));
+    tt_int_op(i,==, 0);
+    tt_int_op(0L,==, tor_parse_long("-"TOOBIG, 10, LONG_MIN, LONG_MAX, &i, NULL));
+    tt_int_op(i,==, 0);
+    tt_int_op(0UL,==, tor_parse_ulong(TOOBIG, 10, 0, ULONG_MAX, &i, NULL));
+    tt_int_op(i,==, 0);
     tt_u64_op(U64_LITERAL(0), ==, tor_parse_uint64(TOOBIG, 10,
                                              0, UINT64_MAX, &i, NULL));
-    test_eq(i, 0);
+    tt_int_op(i,==, 0);
   }
 
   /* Test snprintf */
   /* Returning -1 when there's not enough room in the output buffer */
-  test_eq(-1, tor_snprintf(buf, 0, "Foo"));
-  test_eq(-1, tor_snprintf(buf, 2, "Foo"));
-  test_eq(-1, tor_snprintf(buf, 3, "Foo"));
-  test_neq(-1, tor_snprintf(buf, 4, "Foo"));
+  tt_int_op(-1,==, tor_snprintf(buf, 0, "Foo"));
+  tt_int_op(-1,==, tor_snprintf(buf, 2, "Foo"));
+  tt_int_op(-1,==, tor_snprintf(buf, 3, "Foo"));
+  tt_int_op(-1,!=, tor_snprintf(buf, 4, "Foo"));
   /* Always NUL-terminate the output */
   tor_snprintf(buf, 5, "abcdef");
-  test_eq(0, buf[4]);
+  tt_int_op(0,==, buf[4]);
   tor_snprintf(buf, 10, "abcdef");
-  test_eq(0, buf[6]);
+  tt_int_op(0,==, buf[6]);
   /* uint64 */
   tor_snprintf(buf, sizeof(buf), "x!"U64_FORMAT"!x",
                U64_PRINTF_ARG(U64_LITERAL(12345678901)));
-  test_streq("x!12345678901!x", buf);
+  tt_str_op("x!12345678901!x",==, buf);
 
   /* Test str{,case}cmpstart */
-  test_assert(strcmpstart("abcdef", "abcdef")==0);
-  test_assert(strcmpstart("abcdef", "abc")==0);
-  test_assert(strcmpstart("abcdef", "abd")<0);
-  test_assert(strcmpstart("abcdef", "abb")>0);
-  test_assert(strcmpstart("ab", "abb")<0);
-  test_assert(strcmpstart("ab", "")==0);
-  test_assert(strcmpstart("ab", "ab ")<0);
-  test_assert(strcasecmpstart("abcdef", "abCdEF")==0);
-  test_assert(strcasecmpstart("abcDeF", "abc")==0);
-  test_assert(strcasecmpstart("abcdef", "Abd")<0);
-  test_assert(strcasecmpstart("Abcdef", "abb")>0);
-  test_assert(strcasecmpstart("ab", "Abb")<0);
-  test_assert(strcasecmpstart("ab", "")==0);
-  test_assert(strcasecmpstart("ab", "ab ")<0);
+  tt_assert(strcmpstart("abcdef", "abcdef")==0);
+  tt_assert(strcmpstart("abcdef", "abc")==0);
+  tt_assert(strcmpstart("abcdef", "abd")<0);
+  tt_assert(strcmpstart("abcdef", "abb")>0);
+  tt_assert(strcmpstart("ab", "abb")<0);
+  tt_assert(strcmpstart("ab", "")==0);
+  tt_assert(strcmpstart("ab", "ab ")<0);
+  tt_assert(strcasecmpstart("abcdef", "abCdEF")==0);
+  tt_assert(strcasecmpstart("abcDeF", "abc")==0);
+  tt_assert(strcasecmpstart("abcdef", "Abd")<0);
+  tt_assert(strcasecmpstart("Abcdef", "abb")>0);
+  tt_assert(strcasecmpstart("ab", "Abb")<0);
+  tt_assert(strcasecmpstart("ab", "")==0);
+  tt_assert(strcasecmpstart("ab", "ab ")<0);
 
   /* Test str{,case}cmpend */
-  test_assert(strcmpend("abcdef", "abcdef")==0);
-  test_assert(strcmpend("abcdef", "def")==0);
-  test_assert(strcmpend("abcdef", "deg")<0);
-  test_assert(strcmpend("abcdef", "dee")>0);
-  test_assert(strcmpend("ab", "aab")>0);
-  test_assert(strcasecmpend("AbcDEF", "abcdef")==0);
-  test_assert(strcasecmpend("abcdef", "dEF")==0);
-  test_assert(strcasecmpend("abcdef", "Deg")<0);
-  test_assert(strcasecmpend("abcDef", "dee")>0);
-  test_assert(strcasecmpend("AB", "abb")<0);
+  tt_assert(strcmpend("abcdef", "abcdef")==0);
+  tt_assert(strcmpend("abcdef", "def")==0);
+  tt_assert(strcmpend("abcdef", "deg")<0);
+  tt_assert(strcmpend("abcdef", "dee")>0);
+  tt_assert(strcmpend("ab", "aab")>0);
+  tt_assert(strcasecmpend("AbcDEF", "abcdef")==0);
+  tt_assert(strcasecmpend("abcdef", "dEF")==0);
+  tt_assert(strcasecmpend("abcdef", "Deg")<0);
+  tt_assert(strcasecmpend("abcDef", "dee")>0);
+  tt_assert(strcasecmpend("AB", "abb")<0);
 
   /* Test digest_is_zero */
   memset(buf,0,20);
   buf[20] = 'x';
-  test_assert(tor_digest_is_zero(buf));
+  tt_assert(tor_digest_is_zero(buf));
   buf[19] = 'x';
-  test_assert(!tor_digest_is_zero(buf));
+  tt_assert(!tor_digest_is_zero(buf));
 
   /* Test mem_is_zero */
   memset(buf,0,128);
   buf[128] = 'x';
-  test_assert(tor_mem_is_zero(buf, 10));
-  test_assert(tor_mem_is_zero(buf, 20));
-  test_assert(tor_mem_is_zero(buf, 128));
-  test_assert(!tor_mem_is_zero(buf, 129));
+  tt_assert(tor_mem_is_zero(buf, 10));
+  tt_assert(tor_mem_is_zero(buf, 20));
+  tt_assert(tor_mem_is_zero(buf, 128));
+  tt_assert(!tor_mem_is_zero(buf, 129));
   buf[60] = (char)255;
-  test_assert(!tor_mem_is_zero(buf, 128));
+  tt_assert(!tor_mem_is_zero(buf, 128));
   buf[0] = (char)1;
-  test_assert(!tor_mem_is_zero(buf, 10));
+  tt_assert(!tor_mem_is_zero(buf, 10));
 
   /* Test 'escaped' */
-  test_assert(NULL == escaped(NULL));
-  test_streq("\"\"", escaped(""));
-  test_streq("\"abcd\"", escaped("abcd"));
-  test_streq("\"\\\\ \\n\\r\\t\\\"\\'\"", escaped("\\ \n\r\t\"'"));
-  test_streq("\"unnecessary \\'backslashes\\'\"",
+  tt_assert(NULL == escaped(NULL));
+  tt_str_op("\"\"",==, escaped(""));
+  tt_str_op("\"abcd\"",==, escaped("abcd"));
+  tt_str_op("\"\\\\ \\n\\r\\t\\\"\\'\"",==, escaped("\\ \n\r\t\"'"));
+  tt_str_op("\"unnecessary \\'backslashes\\'\"",==,
              escaped("unnecessary \'backslashes\'"));
   /* Non-printable characters appear as octal */
-  test_streq("\"z\\001abc\\277d\"",  escaped("z\001abc\277d"));
-  test_streq("\"z\\336\\255 ;foo\"", escaped("z\xde\xad\x20;foo"));
+  tt_str_op("\"z\\001abc\\277d\"",==,  escaped("z\001abc\277d"));
+  tt_str_op("\"z\\336\\255 ;foo\"",==, escaped("z\xde\xad\x20;foo"));
 
   /* Test strndup and memdup */
   {
     const char *s = "abcdefghijklmnopqrstuvwxyz";
     cp_tmp = tor_strndup(s, 30);
-    test_streq(cp_tmp, s); /* same string, */
+    tt_str_op(cp_tmp,==, s); /* same string, */
     test_neq_ptr(cp_tmp, s); /* but different pointers. */
     tor_free(cp_tmp);
 
     cp_tmp = tor_strndup(s, 5);
-    test_streq(cp_tmp, "abcde");
+    tt_str_op(cp_tmp,==, "abcde");
     tor_free(cp_tmp);
 
     s = "a\0b\0c\0d\0e\0";
     cp_tmp = tor_memdup(s,10);
-    test_memeq(cp_tmp, s, 10); /* same ram, */
+    tt_mem_op(cp_tmp,==, s, 10); /* same ram, */
     test_neq_ptr(cp_tmp, s); /* but different pointers. */
     tor_free(cp_tmp);
   }
 
   /* Test str-foo functions */
   cp_tmp = tor_strdup("abcdef");
-  test_assert(tor_strisnonupper(cp_tmp));
+  tt_assert(tor_strisnonupper(cp_tmp));
   cp_tmp[3] = 'D';
-  test_assert(!tor_strisnonupper(cp_tmp));
+  tt_assert(!tor_strisnonupper(cp_tmp));
   tor_strupper(cp_tmp);
-  test_streq(cp_tmp, "ABCDEF");
+  tt_str_op(cp_tmp,==, "ABCDEF");
   tor_strlower(cp_tmp);
-  test_streq(cp_tmp, "abcdef");
-  test_assert(tor_strisnonupper(cp_tmp));
-  test_assert(tor_strisprint(cp_tmp));
+  tt_str_op(cp_tmp,==, "abcdef");
+  tt_assert(tor_strisnonupper(cp_tmp));
+  tt_assert(tor_strisprint(cp_tmp));
   cp_tmp[3] = 3;
-  test_assert(!tor_strisprint(cp_tmp));
+  tt_assert(!tor_strisprint(cp_tmp));
   tor_free(cp_tmp);
 
   /* Test memmem and memstr */
   {
     const char *haystack = "abcde";
-    test_assert(!tor_memmem(haystack, 5, "ef", 2));
-    test_eq_ptr(tor_memmem(haystack, 5, "cd", 2), haystack + 2);
-    test_eq_ptr(tor_memmem(haystack, 5, "cde", 3), haystack + 2);
-    test_assert(!tor_memmem(haystack, 4, "cde", 3));
+    tt_assert(!tor_memmem(haystack, 5, "ef", 2));
+    tt_ptr_op(tor_memmem(haystack, 5, "cd", 2),==, haystack + 2);
+    tt_ptr_op(tor_memmem(haystack, 5, "cde", 3),==, haystack + 2);
+    tt_assert(!tor_memmem(haystack, 4, "cde", 3));
     haystack = "ababcad";
-    test_eq_ptr(tor_memmem(haystack, 7, "abc", 3), haystack + 2);
-    test_eq_ptr(tor_memmem(haystack, 7, "ad", 2), haystack + 5);
-    test_eq_ptr(tor_memmem(haystack, 7, "cad", 3), haystack + 4);
-    test_assert(!tor_memmem(haystack, 7, "dadad", 5));
-    test_assert(!tor_memmem(haystack, 7, "abcdefghij", 10));
+    tt_ptr_op(tor_memmem(haystack, 7, "abc", 3),==, haystack + 2);
+    tt_ptr_op(tor_memmem(haystack, 7, "ad", 2),==, haystack + 5);
+    tt_ptr_op(tor_memmem(haystack, 7, "cad", 3),==, haystack + 4);
+    tt_assert(!tor_memmem(haystack, 7, "dadad", 5));
+    tt_assert(!tor_memmem(haystack, 7, "abcdefghij", 10));
     /* memstr */
-    test_eq_ptr(tor_memstr(haystack, 7, "abc"), haystack + 2);
-    test_eq_ptr(tor_memstr(haystack, 7, "cad"), haystack + 4);
-    test_assert(!tor_memstr(haystack, 6, "cad"));
-    test_assert(!tor_memstr(haystack, 7, "cadd"));
-    test_assert(!tor_memstr(haystack, 7, "fe"));
-    test_assert(!tor_memstr(haystack, 7, "ababcade"));
+    tt_ptr_op(tor_memstr(haystack, 7, "abc"),==, haystack + 2);
+    tt_ptr_op(tor_memstr(haystack, 7, "cad"),==, haystack + 4);
+    tt_assert(!tor_memstr(haystack, 6, "cad"));
+    tt_assert(!tor_memstr(haystack, 7, "cadd"));
+    tt_assert(!tor_memstr(haystack, 7, "fe"));
+    tt_assert(!tor_memstr(haystack, 7, "ababcade"));
   }
 
   /* Test hex_str */
@@ -1256,19 +1256,19 @@ test_util_strmisc(void)
     size_t i;
     for (i = 0; i < sizeof(binary_data); ++i)
       binary_data[i] = i;
-    test_streq(hex_str(binary_data, 0), "");
-    test_streq(hex_str(binary_data, 1), "00");
-    test_streq(hex_str(binary_data, 17), "000102030405060708090A0B0C0D0E0F10");
-    test_streq(hex_str(binary_data, 32),
+    tt_str_op(hex_str(binary_data, 0),==, "");
+    tt_str_op(hex_str(binary_data, 1),==, "00");
+    tt_str_op(hex_str(binary_data, 17),==, "000102030405060708090A0B0C0D0E0F10");
+    tt_str_op(hex_str(binary_data, 32),==,
                "000102030405060708090A0B0C0D0E0F"
                "101112131415161718191A1B1C1D1E1F");
-    test_streq(hex_str(binary_data, 34),
+    tt_str_op(hex_str(binary_data, 34),==,
                "000102030405060708090A0B0C0D0E0F"
                "101112131415161718191A1B1C1D1E1F");
     /* Repeat these tests for shorter strings after longer strings
        have been tried, to make sure we're correctly terminating strings */
-    test_streq(hex_str(binary_data, 1), "00");
-    test_streq(hex_str(binary_data, 0), "");
+    tt_str_op(hex_str(binary_data, 1),==, "00");
+    tt_str_op(hex_str(binary_data, 0),==, "");
   }
 
   /* Test strcmp_opt */
@@ -1300,17 +1300,17 @@ static void
 test_util_pow2(void)
 {
   /* Test tor_log2(). */
-  test_eq(tor_log2(64), 6);
-  test_eq(tor_log2(65), 6);
-  test_eq(tor_log2(63), 5);
-  test_eq(tor_log2(0), 0); /* incorrect mathematically, but as specified */
-  test_eq(tor_log2(1), 0);
-  test_eq(tor_log2(2), 1);
-  test_eq(tor_log2(3), 1);
-  test_eq(tor_log2(4), 2);
-  test_eq(tor_log2(5), 2);
-  test_eq(tor_log2(U64_LITERAL(40000000000000000)), 55);
-  test_eq(tor_log2(UINT64_MAX), 63);
+  tt_int_op(tor_log2(64),==, 6);
+  tt_int_op(tor_log2(65),==, 6);
+  tt_int_op(tor_log2(63),==, 5);
+  tt_int_op(tor_log2(0),==, 0); /* incorrect mathematically, but as specified */
+  tt_int_op(tor_log2(1),==, 0);
+  tt_int_op(tor_log2(2),==, 1);
+  tt_int_op(tor_log2(3),==, 1);
+  tt_int_op(tor_log2(4),==, 2);
+  tt_int_op(tor_log2(5),==, 2);
+  tt_int_op(tor_log2(U64_LITERAL(40000000000000000)),==, 55);
+  tt_int_op(tor_log2(UINT64_MAX),==, 63);
 
   /* Test round_to_power_of_2 */
   tt_u64_op(round_to_power_of_2(120), ==, 128);
@@ -1442,15 +1442,15 @@ test_util_threads(void)
 
   if (timedout) {
     printf("\nTimed out: %d %d", t1_count, t2_count);
-    test_assert(strmap_get(thread_test_strmap_, "thread 1"));
-    test_assert(strmap_get(thread_test_strmap_, "thread 2"));
-    test_assert(!timedout);
+    tt_assert(strmap_get(thread_test_strmap_, "thread 1"));
+    tt_assert(strmap_get(thread_test_strmap_, "thread 2"));
+    tt_assert(!timedout);
   }
 
   /* different thread IDs. */
-  test_assert(strcmp(strmap_get(thread_test_strmap_, "thread 1"),
+  tt_assert(strcmp(strmap_get(thread_test_strmap_, "thread 1"),
                      strmap_get(thread_test_strmap_, "thread 2")));
-  test_assert(!strcmp(strmap_get(thread_test_strmap_, "thread 1"),
+  tt_assert(!strcmp(strmap_get(thread_test_strmap_, "thread 1"),
                       strmap_get(thread_test_strmap_, "last to run")) ||
               !strcmp(strmap_get(thread_test_strmap_, "thread 2"),
                       strmap_get(thread_test_strmap_, "last to run")));
@@ -1478,43 +1478,43 @@ test_util_gzip(void)
   tor_zlib_state_t *state = NULL;
 
   buf1 = tor_strdup("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAAAAAAAAAAAAAAAAZ");
-  test_assert(detect_compression_method(buf1, strlen(buf1)) == UNKNOWN_METHOD);
+  tt_assert(detect_compression_method(buf1, strlen(buf1)) == UNKNOWN_METHOD);
   if (is_gzip_supported()) {
-    test_assert(!tor_gzip_compress(&buf2, &len1, buf1, strlen(buf1)+1,
+    tt_assert(!tor_gzip_compress(&buf2, &len1, buf1, strlen(buf1)+1,
                                    GZIP_METHOD));
-    test_assert(buf2);
-    test_assert(len1 < strlen(buf1));
-    test_assert(detect_compression_method(buf2, len1) == GZIP_METHOD);
+    tt_assert(buf2);
+    tt_assert(len1 < strlen(buf1));
+    tt_assert(detect_compression_method(buf2, len1) == GZIP_METHOD);
 
-    test_assert(!tor_gzip_uncompress(&buf3, &len2, buf2, len1,
+    tt_assert(!tor_gzip_uncompress(&buf3, &len2, buf2, len1,
                                      GZIP_METHOD, 1, LOG_INFO));
-    test_assert(buf3);
-    test_eq(strlen(buf1) + 1, len2);
-    test_streq(buf1, buf3);
+    tt_assert(buf3);
+    tt_int_op(strlen(buf1) + 1,==, len2);
+    tt_str_op(buf1,==, buf3);
 
     tor_free(buf2);
     tor_free(buf3);
   }
 
-  test_assert(!tor_gzip_compress(&buf2, &len1, buf1, strlen(buf1)+1,
+  tt_assert(!tor_gzip_compress(&buf2, &len1, buf1, strlen(buf1)+1,
                                  ZLIB_METHOD));
-  test_assert(buf2);
-  test_assert(detect_compression_method(buf2, len1) == ZLIB_METHOD);
+  tt_assert(buf2);
+  tt_assert(detect_compression_method(buf2, len1) == ZLIB_METHOD);
 
-  test_assert(!tor_gzip_uncompress(&buf3, &len2, buf2, len1,
+  tt_assert(!tor_gzip_uncompress(&buf3, &len2, buf2, len1,
                                    ZLIB_METHOD, 1, LOG_INFO));
-  test_assert(buf3);
-  test_eq(strlen(buf1) + 1, len2);
-  test_streq(buf1, buf3);
+  tt_assert(buf3);
+  tt_int_op(strlen(buf1) + 1,==, len2);
+  tt_str_op(buf1,==, buf3);
 
   /* Check whether we can uncompress concatenated, compressed strings. */
   tor_free(buf3);
   buf2 = tor_reallocarray(buf2, len1, 2);
   memcpy(buf2+len1, buf2, len1);
-  test_assert(!tor_gzip_uncompress(&buf3, &len2, buf2, len1*2,
+  tt_assert(!tor_gzip_uncompress(&buf3, &len2, buf2, len1*2,
                                    ZLIB_METHOD, 1, LOG_INFO));
-  test_eq((strlen(buf1)+1)*2, len2);
-  test_memeq(buf3,
+  tt_int_op((strlen(buf1)+1)*2,==, len2);
+  tt_mem_op(buf3,==,
              "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAAAAAAAAAAAAAAAAZ\0"
              "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAAAAAAAAAAAAAAAAZ\0",
              (strlen(buf1)+1)*2);
@@ -1526,7 +1526,7 @@ test_util_gzip(void)
   /* Check whether we can uncompress partial strings. */
   buf1 =
     tor_strdup("String with low redundancy that won't be compressed much.");
-  test_assert(!tor_gzip_compress(&buf2, &len1, buf1, strlen(buf1)+1,
+  tt_assert(!tor_gzip_compress(&buf2, &len1, buf1, strlen(buf1)+1,
                                  ZLIB_METHOD));
   tt_assert(len1>16);
   /* when we allow an incomplete string, we should succeed.*/
@@ -1552,22 +1552,22 @@ test_util_gzip(void)
   len1 = 1024;
   ccp2 = "ABCDEFGHIJABCDEFGHIJ";
   len2 = 21;
-  test_assert(tor_zlib_process(state, &cp1, &len1, &ccp2, &len2, 0)
+  tt_assert(tor_zlib_process(state, &cp1, &len1, &ccp2, &len2, 0)
               == TOR_ZLIB_OK);
-  test_eq(0, len2); /* Make sure we compressed it all. */
-  test_assert(cp1 > buf1);
+  tt_int_op(0,==, len2); /* Make sure we compressed it all. */
+  tt_assert(cp1 > buf1);
 
   len2 = 0;
   cp2 = cp1;
-  test_assert(tor_zlib_process(state, &cp1, &len1, &ccp2, &len2, 1)
+  tt_assert(tor_zlib_process(state, &cp1, &len1, &ccp2, &len2, 1)
               == TOR_ZLIB_DONE);
-  test_eq(0, len2);
-  test_assert(cp1 > cp2); /* Make sure we really added something. */
+  tt_int_op(0,==, len2);
+  tt_assert(cp1 > cp2); /* Make sure we really added something. */
 
   tt_assert(!tor_gzip_uncompress(&buf3, &len2, buf1, 1024-len1,
                                   ZLIB_METHOD, 1, LOG_WARN));
-  test_streq(buf3, "ABCDEFGHIJABCDEFGHIJ"); /*Make sure it compressed right.*/
-  test_eq(21, len2);
+  tt_str_op(buf3,==, "ABCDEFGHIJABCDEFGHIJ"); /*Make sure it compressed right.*/
+  tt_int_op(21,==, len2);
 
  done:
   if (state)
@@ -1591,22 +1591,22 @@ test_util_mmap(void)
   crypto_rand(buf, buflen);
 
   mapping = tor_mmap_file(fname1);
-  test_assert(! mapping);
+  tt_assert(! mapping);
 
   write_str_to_file(fname1, "Short file.", 1);
 
   mapping = tor_mmap_file(fname1);
-  test_assert(mapping);
-  test_eq(mapping->size, strlen("Short file."));
-  test_streq(mapping->data, "Short file.");
+  tt_assert(mapping);
+  tt_int_op(mapping->size,==, strlen("Short file."));
+  tt_str_op(mapping->data,==, "Short file.");
 #ifdef _WIN32
   tt_int_op(0, ==, tor_munmap_file(mapping));
   mapping = NULL;
-  test_assert(unlink(fname1) == 0);
+  tt_assert(unlink(fname1) == 0);
 #else
   /* make sure we can unlink. */
-  test_assert(unlink(fname1) == 0);
-  test_streq(mapping->data, "Short file.");
+  tt_assert(unlink(fname1) == 0);
+  tt_str_op(mapping->data,==, "Short file.");
   tt_int_op(0, ==, tor_munmap_file(mapping));
   mapping = NULL;
 #endif
@@ -1614,29 +1614,29 @@ test_util_mmap(void)
   /* Now a zero-length file. */
   write_str_to_file(fname1, "", 1);
   mapping = tor_mmap_file(fname1);
-  test_eq_ptr(mapping, NULL);
-  test_eq(ERANGE, errno);
+  tt_ptr_op(mapping,==, NULL);
+  tt_int_op(ERANGE,==, errno);
   unlink(fname1);
 
   /* Make sure that we fail to map a no-longer-existent file. */
   mapping = tor_mmap_file(fname1);
-  test_assert(! mapping);
+  tt_assert(! mapping);
 
   /* Now try a big file that stretches across a few pages and isn't aligned */
   write_bytes_to_file(fname2, buf, buflen, 1);
   mapping = tor_mmap_file(fname2);
-  test_assert(mapping);
-  test_eq(mapping->size, buflen);
-  test_memeq(mapping->data, buf, buflen);
+  tt_assert(mapping);
+  tt_int_op(mapping->size,==, buflen);
+  tt_mem_op(mapping->data,==, buf, buflen);
   tt_int_op(0, ==, tor_munmap_file(mapping));
   mapping = NULL;
 
   /* Now try a big aligned file. */
   write_bytes_to_file(fname3, buf, 16384, 1);
   mapping = tor_mmap_file(fname3);
-  test_assert(mapping);
-  test_eq(mapping->size, 16384);
-  test_memeq(mapping->data, buf, 16384);
+  tt_assert(mapping);
+  tt_int_op(mapping->size,==, 16384);
+  tt_mem_op(mapping->data,==, buf, 16384);
   tt_int_op(0, ==, tor_munmap_file(mapping));
   mapping = NULL;
 
@@ -1663,9 +1663,9 @@ test_util_control_formats(void)
   size_t sz;
 
   sz = read_escaped_data(inp, strlen(inp), &out);
-  test_streq(out,
+  tt_str_op(out,==,
              ".This is a test\nof the emergency \n.system.\n\rZ.\n");
-  test_eq(sz, strlen(out));
+  tt_int_op(sz,==, strlen(out));
 
  done:
   tor_free(out);
@@ -1696,326 +1696,326 @@ test_util_sscanf(void)
   double d1,d2,d3,d4;
 
   /* Simple tests (malformed patterns, literal matching, ...) */
-  test_eq(-1, tor_sscanf("123", "%i", &r)); /* %i is not supported */
-  test_eq(-1, tor_sscanf("wrong", "%5c", s1)); /* %c cannot have a number. */
-  test_eq(-1, tor_sscanf("hello", "%s", s1)); /* %s needs a number. */
-  test_eq(-1, tor_sscanf("prettylongstring", "%999999s", s1));
+  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. */
+  tt_int_op(-1,==, tor_sscanf("prettylongstring", "%999999s", s1));
 #if 0
   /* GCC thinks these two are illegal. */
   test_eq(-1, tor_sscanf("prettylongstring", "%0s", s1));
   test_eq(0, tor_sscanf("prettylongstring", "%10s", NULL));
 #endif
   /* No '%'-strings: always "success" */
-  test_eq(0, tor_sscanf("hello world", "hello world"));
-  test_eq(0, tor_sscanf("hello world", "good bye"));
+  tt_int_op(0,==, tor_sscanf("hello world", "hello world"));
+  tt_int_op(0,==, tor_sscanf("hello world", "good bye"));
   /* Excess data */
-  test_eq(0, tor_sscanf("hello 3", "%u", &u1));  /* have to match the start */
-  test_eq(0, tor_sscanf(" 3 hello", "%u", &u1));
-  test_eq(0, tor_sscanf(" 3 hello", "%2u", &u1)); /* not even in this case */
-  test_eq(1, tor_sscanf("3 hello", "%u", &u1));  /* but trailing is alright */
+  tt_int_op(0,==, tor_sscanf("hello 3", "%u", &u1));  /* have to match the start */
+  tt_int_op(0,==, tor_sscanf(" 3 hello", "%u", &u1));
+  tt_int_op(0,==, tor_sscanf(" 3 hello", "%2u", &u1)); /* not even in this case */
+  tt_int_op(1,==, tor_sscanf("3 hello", "%u", &u1));  /* but trailing is alright */
 
   /* Numbers (ie. %u) */
-  test_eq(0, tor_sscanf("hello world 3", "hello worlb %u", &u1)); /* d vs b */
-  test_eq(1, tor_sscanf("12345", "%u", &u1));
-  test_eq(12345u, u1);
-  test_eq(1, tor_sscanf("12346 ", "%u", &u1));
-  test_eq(12346u, u1);
-  test_eq(0, tor_sscanf(" 12347", "%u", &u1));
-  test_eq(1, tor_sscanf(" 12348", " %u", &u1));
-  test_eq(12348u, u1);
-  test_eq(1, tor_sscanf("0", "%u", &u1));
-  test_eq(0u, u1);
-  test_eq(1, tor_sscanf("0000", "%u", &u2));
-  test_eq(0u, u2);
-  test_eq(0, tor_sscanf("", "%u", &u1)); /* absent number */
-  test_eq(0, tor_sscanf("A", "%u", &u1)); /* bogus number */
-  test_eq(0, tor_sscanf("-1", "%u", &u1)); /* negative number */
+  tt_int_op(0,==, tor_sscanf("hello world 3", "hello worlb %u", &u1)); /* d vs b */
+  tt_int_op(1,==, tor_sscanf("12345", "%u", &u1));
+  tt_int_op(12345u,==, u1);
+  tt_int_op(1,==, tor_sscanf("12346 ", "%u", &u1));
+  tt_int_op(12346u,==, u1);
+  tt_int_op(0,==, tor_sscanf(" 12347", "%u", &u1));
+  tt_int_op(1,==, tor_sscanf(" 12348", " %u", &u1));
+  tt_int_op(12348u,==, u1);
+  tt_int_op(1,==, tor_sscanf("0", "%u", &u1));
+  tt_int_op(0u,==, u1);
+  tt_int_op(1,==, tor_sscanf("0000", "%u", &u2));
+  tt_int_op(0u,==, u2);
+  tt_int_op(0,==, tor_sscanf("", "%u", &u1)); /* absent number */
+  tt_int_op(0,==, tor_sscanf("A", "%u", &u1)); /* bogus number */
+  tt_int_op(0,==, tor_sscanf("-1", "%u", &u1)); /* negative number */
 
   /* Numbers with size (eg. %2u) */
-  test_eq(0, tor_sscanf("-1", "%2u", &u1));
-  test_eq(2, tor_sscanf("123456", "%2u%u", &u1, &u2));
-  test_eq(12u, u1);
-  test_eq(3456u, u2);
-  test_eq(1, tor_sscanf("123456", "%8u", &u1));
-  test_eq(123456u, u1);
-  test_eq(1, tor_sscanf("123457  ", "%8u", &u1));
-  test_eq(123457u, u1);
-  test_eq(0, tor_sscanf("  123456", "%8u", &u1));
-  test_eq(3, tor_sscanf("!12:3:456", "!%2u:%2u:%3u", &u1, &u2, &u3));
-  test_eq(12u, u1);
-  test_eq(3u, u2);
-  test_eq(456u, u3);
-  test_eq(3, tor_sscanf("67:8:099", "%2u:%2u:%3u", &u1, &u2, &u3)); /* 0s */
-  test_eq(67u, u1);
-  test_eq(8u, u2);
-  test_eq(99u, u3);
+  tt_int_op(0,==, tor_sscanf("-1", "%2u", &u1));
+  tt_int_op(2,==, tor_sscanf("123456", "%2u%u", &u1, &u2));
+  tt_int_op(12u,==, u1);
+  tt_int_op(3456u,==, u2);
+  tt_int_op(1,==, tor_sscanf("123456", "%8u", &u1));
+  tt_int_op(123456u,==, u1);
+  tt_int_op(1,==, tor_sscanf("123457  ", "%8u", &u1));
+  tt_int_op(123457u,==, u1);
+  tt_int_op(0,==, tor_sscanf("  123456", "%8u", &u1));
+  tt_int_op(3,==, tor_sscanf("!12:3:456", "!%2u:%2u:%3u", &u1, &u2, &u3));
+  tt_int_op(12u,==, u1);
+  tt_int_op(3u,==, u2);
+  tt_int_op(456u,==, u3);
+  tt_int_op(3,==, tor_sscanf("67:8:099", "%2u:%2u:%3u", &u1, &u2, &u3)); /* 0s */
+  tt_int_op(67u,==, u1);
+  tt_int_op(8u,==, u2);
+  tt_int_op(99u,==, u3);
   /* %u does not match space.*/
-  test_eq(2, tor_sscanf("12:3: 45", "%2u:%2u:%3u", &u1, &u2, &u3));
-  test_eq(12u, u1);
-  test_eq(3u, u2);
+  tt_int_op(2,==, tor_sscanf("12:3: 45", "%2u:%2u:%3u", &u1, &u2, &u3));
+  tt_int_op(12u,==, u1);
+  tt_int_op(3u,==, u2);
   /* %u does not match negative numbers. */
-  test_eq(2, tor_sscanf("67:8:-9", "%2u:%2u:%3u", &u1, &u2, &u3));
-  test_eq(67u, u1);
-  test_eq(8u, u2);
+  tt_int_op(2,==, tor_sscanf("67:8:-9", "%2u:%2u:%3u", &u1, &u2, &u3));
+  tt_int_op(67u,==, u1);
+  tt_int_op(8u,==, u2);
   /* Arbitrary amounts of 0-padding are okay */
-  test_eq(3, tor_sscanf("12:03:000000000000000099", "%2u:%2u:%u",
+  tt_int_op(3,==, tor_sscanf("12:03:000000000000000099", "%2u:%2u:%u",
                         &u1, &u2, &u3));
-  test_eq(12u, u1);
-  test_eq(3u, u2);
-  test_eq(99u, u3);
+  tt_int_op(12u,==, u1);
+  tt_int_op(3u,==, u2);
+  tt_int_op(99u,==, u3);
 
   /* Hex (ie. %x) */
-  test_eq(3, tor_sscanf("1234 02aBcdEf ff", "%x %x %x", &u1, &u2, &u3));
-  test_eq(0x1234, u1);
-  test_eq(0x2ABCDEF, u2);
-  test_eq(0xFF, u3);
+  tt_int_op(3,==, tor_sscanf("1234 02aBcdEf ff", "%x %x %x", &u1, &u2, &u3));
+  tt_int_op(0x1234,==, u1);
+  tt_int_op(0x2ABCDEF,==, u2);
+  tt_int_op(0xFF,==, u3);
   /* Width works on %x */
-  test_eq(3, tor_sscanf("f00dcafe444", "%4x%4x%u", &u1, &u2, &u3));
-  test_eq(0xf00d, u1);
-  test_eq(0xcafe, u2);
-  test_eq(444, u3);
+  tt_int_op(3,==, tor_sscanf("f00dcafe444", "%4x%4x%u", &u1, &u2, &u3));
+  tt_int_op(0xf00d,==, u1);
+  tt_int_op(0xcafe,==, u2);
+  tt_int_op(444,==, u3);
 
   /* Literal '%' (ie. '%%') */
-  test_eq(1, tor_sscanf("99% fresh", "%3u%% fresh", &u1));
-  test_eq(99, u1);
-  test_eq(0, tor_sscanf("99 fresh", "%% %3u %s", &u1, s1));
-  test_eq(1, tor_sscanf("99 fresh", "%3u%% %s", &u1, s1));
-  test_eq(2, tor_sscanf("99 fresh", "%3u %5s %%", &u1, s1));
-  test_eq(99, u1);
-  test_streq(s1, "fresh");
-  test_eq(1, tor_sscanf("% boo", "%% %3s", s1));
-  test_streq("boo", s1);
+  tt_int_op(1,==, tor_sscanf("99% fresh", "%3u%% fresh", &u1));
+  tt_int_op(99,==, u1);
+  tt_int_op(0,==, tor_sscanf("99 fresh", "%% %3u %s", &u1, s1));
+  tt_int_op(1,==, tor_sscanf("99 fresh", "%3u%% %s", &u1, s1));
+  tt_int_op(2,==, tor_sscanf("99 fresh", "%3u %5s %%", &u1, s1));
+  tt_int_op(99,==, u1);
+  tt_str_op(s1,==, "fresh");
+  tt_int_op(1,==, tor_sscanf("% boo", "%% %3s", s1));
+  tt_str_op("boo",==, s1);
 
   /* Strings (ie. %s) */
-  test_eq(2, tor_sscanf("hello", "%3s%7s", s1, s2));
-  test_streq(s1, "hel");
-  test_streq(s2, "lo");
-  test_eq(2, tor_sscanf("WD40", "%2s%u", s3, &u1)); /* %s%u */
-  test_streq(s3, "WD");
-  test_eq(40, u1);
-  test_eq(2, tor_sscanf("WD40", "%3s%u", s3, &u1)); /* %s%u */
-  test_streq(s3, "WD4");
-  test_eq(0, u1);
-  test_eq(2, tor_sscanf("76trombones", "%6u%9s", &u1, s1)); /* %u%s */
-  test_eq(76, u1);
-  test_streq(s1, "trombones");
-  test_eq(1, tor_sscanf("prettylongstring", "%999s", s1));
-  test_streq(s1, "prettylongstring");
+  tt_int_op(2,==, tor_sscanf("hello", "%3s%7s", s1, s2));
+  tt_str_op(s1,==, "hel");
+  tt_str_op(s2,==, "lo");
+  tt_int_op(2,==, tor_sscanf("WD40", "%2s%u", s3, &u1)); /* %s%u */
+  tt_str_op(s3,==, "WD");
+  tt_int_op(40,==, u1);
+  tt_int_op(2,==, tor_sscanf("WD40", "%3s%u", s3, &u1)); /* %s%u */
+  tt_str_op(s3,==, "WD4");
+  tt_int_op(0,==, u1);
+  tt_int_op(2,==, tor_sscanf("76trombones", "%6u%9s", &u1, s1)); /* %u%s */
+  tt_int_op(76,==, u1);
+  tt_str_op(s1,==, "trombones");
+  tt_int_op(1,==, tor_sscanf("prettylongstring", "%999s", s1));
+  tt_str_op(s1,==, "prettylongstring");
   /* %s doesn't eat spaces */
-  test_eq(2, tor_sscanf("hello world", "%9s %9s", s1, s2));
-  test_streq(s1, "hello");
-  test_streq(s2, "world");
-  test_eq(2, tor_sscanf("bye   world?", "%9s %9s", s1, s2));
-  test_streq(s1, "bye");
-  test_streq(s2, "");
-  test_eq(3, tor_sscanf("hi", "%9s%9s%3s", s1, s2, s3)); /* %s can be empty. */
-  test_streq(s1, "hi");
-  test_streq(s2, "");
-  test_streq(s3, "");
+  tt_int_op(2,==, tor_sscanf("hello world", "%9s %9s", s1, s2));
+  tt_str_op(s1,==, "hello");
+  tt_str_op(s2,==, "world");
+  tt_int_op(2,==, tor_sscanf("bye   world?", "%9s %9s", s1, s2));
+  tt_str_op(s1,==, "bye");
+  tt_str_op(s2,==, "");
+  tt_int_op(3,==, tor_sscanf("hi", "%9s%9s%3s", s1, s2, s3)); /* %s can be empty. */
+  tt_str_op(s1,==, "hi");
+  tt_str_op(s2,==, "");
+  tt_str_op(s3,==, "");
 
-  test_eq(3, tor_sscanf("1.2.3", "%u.%u.%u%c", &u1, &u2, &u3, &ch));
-  test_eq(4, tor_sscanf("1.2.3 foobar", "%u.%u.%u%c", &u1, &u2, &u3, &ch));
-  test_eq(' ', ch);
+  tt_int_op(3,==, tor_sscanf("1.2.3", "%u.%u.%u%c", &u1, &u2, &u3, &ch));
+  tt_int_op(4,==, tor_sscanf("1.2.3 foobar", "%u.%u.%u%c", &u1, &u2, &u3, &ch));
+  tt_int_op(' ',==, ch);
 
   r = tor_sscanf("12345 -67890 -1", "%d %ld %d", &int1, &lng1, &int2);
-  test_eq(r,3);
-  test_eq(int1, 12345);
-  test_eq(lng1, -67890);
-  test_eq(int2, -1);
+  tt_int_op(r,==, 3);
+  tt_int_op(int1,==, 12345);
+  tt_int_op(lng1,==, -67890);
+  tt_int_op(int2,==, -1);
 
 #if SIZEOF_INT == 4
   /* %u */
   /* UINT32_MAX should work */
-  test_eq(1, tor_sscanf("4294967295", "%u", &u1));
-  test_eq(4294967295U, u1);
+  tt_int_op(1,==, tor_sscanf("4294967295", "%u", &u1));
+  tt_int_op(4294967295U,==, u1);
 
   /* But UINT32_MAX + 1 shouldn't work */
-  test_eq(0, tor_sscanf("4294967296", "%u", &u1));
+  tt_int_op(0,==, tor_sscanf("4294967296", "%u", &u1));
   /* but parsing only 9... */
-  test_eq(1, tor_sscanf("4294967296", "%9u", &u1));
-  test_eq(429496729U, u1);
+  tt_int_op(1,==, tor_sscanf("4294967296", "%9u", &u1));
+  tt_int_op(429496729U,==, u1);
 
   /* %x */
   /* UINT32_MAX should work */
-  test_eq(1, tor_sscanf("FFFFFFFF", "%x", &u1));
-  test_eq(0xFFFFFFFF, u1);
+  tt_int_op(1,==, tor_sscanf("FFFFFFFF", "%x", &u1));
+  tt_int_op(0xFFFFFFFF,==, u1);
 
   /* But UINT32_MAX + 1 shouldn't work */
-  test_eq(0, tor_sscanf("100000000", "%x", &u1));
+  tt_int_op(0,==, tor_sscanf("100000000", "%x", &u1));
 
   /* %d */
   /* INT32_MIN and INT32_MAX should work */
   r = tor_sscanf("-2147483648. 2147483647.", "%d. %d.", &int1, &int2);
-  test_eq(r,2);
-  test_eq(int1, -2147483647 - 1);
-  test_eq(int2, 2147483647);
+  tt_int_op(r,==, 2);
+  tt_int_op(int1,==, -2147483647 - 1);
+  tt_int_op(int2,==, 2147483647);
 
   /* But INT32_MIN - 1 and INT32_MAX + 1 shouldn't work */
   r = tor_sscanf("-2147483649.", "%d.", &int1);
-  test_eq(r,0);
+  tt_int_op(r,==, 0);
 
   r = tor_sscanf("2147483648.", "%d.", &int1);
-  test_eq(r,0);
+  tt_int_op(r,==, 0);
 
   /* and the first failure stops further processing */
   r = tor_sscanf("-2147483648. 2147483648.",
                  "%d. %d.", &int1, &int2);
-  test_eq(r,1);
+  tt_int_op(r,==, 1);
 
   r = tor_sscanf("-2147483649. 2147483647.",
                  "%d. %d.", &int1, &int2);
-  test_eq(r,0);
+  tt_int_op(r,==, 0);
 
   r = tor_sscanf("2147483648. -2147483649.",
                  "%d. %d.", &int1, &int2);
-  test_eq(r,0);
+  tt_int_op(r,==, 0);
 #elif SIZEOF_INT == 8
   /* %u */
   /* UINT64_MAX should work */
-  test_eq(1, tor_sscanf("18446744073709551615", "%u", &u1));
-  test_eq(18446744073709551615U, u1);
+  tt_int_op(1,==, tor_sscanf("18446744073709551615", "%u", &u1));
+  tt_int_op(18446744073709551615U,==, u1);
 
   /* But UINT64_MAX + 1 shouldn't work */
-  test_eq(0, tor_sscanf("18446744073709551616", "%u", &u1));
+  tt_int_op(0,==, tor_sscanf("18446744073709551616", "%u", &u1));
   /* but parsing only 19... */
-  test_eq(1, tor_sscanf("18446744073709551616", "%19u", &u1));
-  test_eq(1844674407370955161U, u1);
+  tt_int_op(1,==, tor_sscanf("18446744073709551616", "%19u", &u1));
+  tt_int_op(1844674407370955161U,==, u1);
 
   /* %x */
   /* UINT64_MAX should work */
-  test_eq(1, tor_sscanf("FFFFFFFFFFFFFFFF", "%x", &u1));
-  test_eq(0xFFFFFFFFFFFFFFFF, u1);
+  tt_int_op(1,==, tor_sscanf("FFFFFFFFFFFFFFFF", "%x", &u1));
+  tt_int_op(0xFFFFFFFFFFFFFFFF,==, u1);
 
   /* But UINT64_MAX + 1 shouldn't work */
-  test_eq(0, tor_sscanf("10000000000000000", "%x", &u1));
+  tt_int_op(0,==, tor_sscanf("10000000000000000", "%x", &u1));
 
   /* %d */
   /* INT64_MIN and INT64_MAX should work */
   r = tor_sscanf("-9223372036854775808. 9223372036854775807.",
                  "%d. %d.", &int1, &int2);
-  test_eq(r,2);
-  test_eq(int1, -9223372036854775807 - 1);
-  test_eq(int2, 9223372036854775807);
+  tt_int_op(r,==, 2);
+  tt_int_op(int1,==, -9223372036854775807 - 1);
+  tt_int_op(int2,==, 9223372036854775807);
 
   /* But INT64_MIN - 1 and INT64_MAX + 1 shouldn't work */
   r = tor_sscanf("-9223372036854775809.", "%d.", &int1);
-  test_eq(r,0);
+  tt_int_op(r,==, 0);
 
   r = tor_sscanf("9223372036854775808.", "%d.", &int1);
-  test_eq(r,0);
+  tt_int_op(r,==, 0);
 
   /* and the first failure stops further processing */
   r = tor_sscanf("-9223372036854775808. 9223372036854775808.",
                  "%d. %d.", &int1, &int2);
-  test_eq(r,1);
+  tt_int_op(r,==, 1);
 
   r = tor_sscanf("-9223372036854775809. 9223372036854775807.",
                  "%d. %d.", &int1, &int2);
-  test_eq(r,0);
+  tt_int_op(r,==, 0);
 
   r = tor_sscanf("9223372036854775808. -9223372036854775809.",
                  "%d. %d.", &int1, &int2);
-  test_eq(r,0);
+  tt_int_op(r,==, 0);
 #endif
 
 #if SIZEOF_LONG == 4
   /* %lu */
   /* UINT32_MAX should work */
-  test_eq(1, tor_sscanf("4294967295", "%lu", &ulng));
-  test_eq(4294967295UL, ulng);
+  tt_int_op(1,==, tor_sscanf("4294967295", "%lu", &ulng));
+  tt_int_op(4294967295UL,==, ulng);
 
   /* But UINT32_MAX + 1 shouldn't work */
-  test_eq(0, tor_sscanf("4294967296", "%lu", &ulng));
+  tt_int_op(0,==, tor_sscanf("4294967296", "%lu", &ulng));
   /* but parsing only 9... */
-  test_eq(1, tor_sscanf("4294967296", "%9lu", &ulng));
-  test_eq(429496729UL, ulng);
+  tt_int_op(1,==, tor_sscanf("4294967296", "%9lu", &ulng));
+  tt_int_op(429496729UL,==, ulng);
 
   /* %lx */
   /* UINT32_MAX should work */
-  test_eq(1, tor_sscanf("FFFFFFFF", "%lx", &ulng));
-  test_eq(0xFFFFFFFFUL, ulng);
+  tt_int_op(1,==, tor_sscanf("FFFFFFFF", "%lx", &ulng));
+  tt_int_op(0xFFFFFFFFUL,==, ulng);
 
   /* But UINT32_MAX + 1 shouldn't work */
-  test_eq(0, tor_sscanf("100000000", "%lx", &ulng));
+  tt_int_op(0,==, tor_sscanf("100000000", "%lx", &ulng));
 
   /* %ld */
   /* INT32_MIN and INT32_MAX should work */
   r = tor_sscanf("-2147483648. 2147483647.", "%ld. %ld.", &lng1, &lng2);
-  test_eq(r,2);
-  test_eq(lng1, -2147483647L - 1L);
-  test_eq(lng2, 2147483647L);
+  tt_int_op(r,==, 2);
+  tt_int_op(lng1,==, -2147483647L - 1L);
+  tt_int_op(lng2,==, 2147483647L);
 
   /* But INT32_MIN - 1 and INT32_MAX + 1 shouldn't work */
   r = tor_sscanf("-2147483649.", "%ld.", &lng1);
-  test_eq(r,0);
+  tt_int_op(r,==, 0);
 
   r = tor_sscanf("2147483648.", "%ld.", &lng1);
-  test_eq(r,0);
+  tt_int_op(r,==, 0);
 
   /* and the first failure stops further processing */
   r = tor_sscanf("-2147483648. 2147483648.",
                  "%ld. %ld.", &lng1, &lng2);
-  test_eq(r,1);
+  tt_int_op(r,==, 1);
 
   r = tor_sscanf("-2147483649. 2147483647.",
                  "%ld. %ld.", &lng1, &lng2);
-  test_eq(r,0);
+  tt_int_op(r,==, 0);
 
   r = tor_sscanf("2147483648. -2147483649.",
                  "%ld. %ld.", &lng1, &lng2);
-  test_eq(r,0);
+  tt_int_op(r,==, 0);
 #elif SIZEOF_LONG == 8
   /* %lu */
   /* UINT64_MAX should work */
-  test_eq(1, tor_sscanf("18446744073709551615", "%lu", &ulng));
-  test_eq(18446744073709551615UL, ulng);
+  tt_int_op(1,==, tor_sscanf("18446744073709551615", "%lu", &ulng));
+  tt_int_op(18446744073709551615UL,==, ulng);
 
   /* But UINT64_MAX + 1 shouldn't work */
-  test_eq(0, tor_sscanf("18446744073709551616", "%lu", &ulng));
+  tt_int_op(0,==, tor_sscanf("18446744073709551616", "%lu", &ulng));
   /* but parsing only 19... */
-  test_eq(1, tor_sscanf("18446744073709551616", "%19lu", &ulng));
-  test_eq(1844674407370955161UL, ulng);
+  tt_int_op(1,==, tor_sscanf("18446744073709551616", "%19lu", &ulng));
+  tt_int_op(1844674407370955161UL,==, ulng);
 
   /* %lx */
   /* UINT64_MAX should work */
-  test_eq(1, tor_sscanf("FFFFFFFFFFFFFFFF", "%lx", &ulng));
-  test_eq(0xFFFFFFFFFFFFFFFFUL, ulng);
+  tt_int_op(1,==, tor_sscanf("FFFFFFFFFFFFFFFF", "%lx", &ulng));
+  tt_int_op(0xFFFFFFFFFFFFFFFFUL,==, ulng);
 
   /* But UINT64_MAX + 1 shouldn't work */
-  test_eq(0, tor_sscanf("10000000000000000", "%lx", &ulng));
+  tt_int_op(0,==, tor_sscanf("10000000000000000", "%lx", &ulng));
 
   /* %ld */
   /* INT64_MIN and INT64_MAX should work */
   r = tor_sscanf("-9223372036854775808. 9223372036854775807.",
                  "%ld. %ld.", &lng1, &lng2);
-  test_eq(r,2);
-  test_eq(lng1, -9223372036854775807L - 1L);
-  test_eq(lng2, 9223372036854775807L);
+  tt_int_op(r,==, 2);
+  tt_int_op(lng1,==, -9223372036854775807L - 1L);
+  tt_int_op(lng2,==, 9223372036854775807L);
 
   /* But INT64_MIN - 1 and INT64_MAX + 1 shouldn't work */
   r = tor_sscanf("-9223372036854775809.", "%ld.", &lng1);
-  test_eq(r,0);
+  tt_int_op(r,==, 0);
 
   r = tor_sscanf("9223372036854775808.", "%ld.", &lng1);
-  test_eq(r,0);
+  tt_int_op(r,==, 0);
 
   /* and the first failure stops further processing */
   r = tor_sscanf("-9223372036854775808. 9223372036854775808.",
                  "%ld. %ld.", &lng1, &lng2);
-  test_eq(r,1);
+  tt_int_op(r,==, 1);
 
   r = tor_sscanf("-9223372036854775809. 9223372036854775807.",
                  "%ld. %ld.", &lng1, &lng2);
-  test_eq(r,0);
+  tt_int_op(r,==, 0);
 
   r = tor_sscanf("9223372036854775808. -9223372036854775809.",
                  "%ld. %ld.", &lng1, &lng2);
-  test_eq(r,0);
+  tt_int_op(r,==, 0);
 #endif
 
   r = tor_sscanf("123.456 .000007 -900123123.2000787 00003.2",
                  "%lf %lf %lf %lf", &d1,&d2,&d3,&d4);
-  test_eq(r,4);
+  tt_int_op(r,==, 4);
   test_feq(d1, 123.456);
   test_feq(d2, .000007);
   test_feq(d3, -900123123.2000787);
@@ -2029,30 +2029,30 @@ static void
 test_util_path_is_relative(void)
 {
   /* OS-independent tests */
-  test_eq(1, path_is_relative(""));
-  test_eq(1, path_is_relative("dir"));
-  test_eq(1, path_is_relative("dir/"));
-  test_eq(1, path_is_relative("./dir"));
-  test_eq(1, path_is_relative("../dir"));
+  tt_int_op(1,==, path_is_relative(""));
+  tt_int_op(1,==, path_is_relative("dir"));
+  tt_int_op(1,==, path_is_relative("dir/"));
+  tt_int_op(1,==, path_is_relative("./dir"));
+  tt_int_op(1,==, path_is_relative("../dir"));
 
-  test_eq(0, path_is_relative("/"));
-  test_eq(0, path_is_relative("/dir"));
-  test_eq(0, path_is_relative("/dir/"));
+  tt_int_op(0,==, path_is_relative("/"));
+  tt_int_op(0,==, path_is_relative("/dir"));
+  tt_int_op(0,==, path_is_relative("/dir/"));
 
   /* Windows */
 #ifdef _WIN32
   /* I don't have Windows so I can't test this, hence the "#ifdef
      0". These are tests that look useful, so please try to get them
      running and uncomment if it all works as it should */
-  test_eq(1, path_is_relative("dir"));
-  test_eq(1, path_is_relative("dir\\"));
-  test_eq(1, path_is_relative("dir\\a:"));
-  test_eq(1, path_is_relative("dir\\a:\\"));
-  test_eq(1, path_is_relative("http:\\dir"));
+  tt_int_op(1,==, path_is_relative("dir"));
+  tt_int_op(1,==, path_is_relative("dir\\"));
+  tt_int_op(1,==, path_is_relative("dir\\a:"));
+  tt_int_op(1,==, path_is_relative("dir\\a:\\"));
+  tt_int_op(1,==, path_is_relative("http:\\dir"));
 
-  test_eq(0, path_is_relative("\\dir"));
-  test_eq(0, path_is_relative("a:\\dir"));
-  test_eq(0, path_is_relative("z:\\dir"));
+  tt_int_op(0,==, path_is_relative("\\dir"));
+  tt_int_op(0,==, path_is_relative("a:\\dir"));
+  tt_int_op(0,==, path_is_relative("z:\\dir"));
 #endif
 
  done:
@@ -2070,18 +2070,18 @@ test_util_mempool(void)
   int i;
 
   pool = mp_pool_new(1, 100);
-  test_assert(pool);
-  test_assert(pool->new_chunk_capacity >= 100);
-  test_assert(pool->item_alloc_size >= sizeof(void*)+1);
+  tt_assert(pool);
+  tt_assert(pool->new_chunk_capacity >= 100);
+  tt_assert(pool->item_alloc_size >= sizeof(void*)+1);
   mp_pool_destroy(pool);
   pool = NULL;
 
   pool = mp_pool_new(241, 2500);
-  test_assert(pool);
-  test_assert(pool->new_chunk_capacity >= 10);
-  test_assert(pool->item_alloc_size >= sizeof(void*)+241);
-  test_eq(pool->item_alloc_size & 0x03, 0);
-  test_assert(pool->new_chunk_capacity < 60);
+  tt_assert(pool);
+  tt_assert(pool->new_chunk_capacity >= 10);
+  tt_assert(pool->item_alloc_size >= sizeof(void*)+241);
+  tt_int_op(pool->item_alloc_size & 0x03,==, 0);
+  tt_assert(pool->new_chunk_capacity < 60);
 
   allocated = smartlist_new();
   for (i = 0; i < 20000; ++i) {
@@ -2130,32 +2130,32 @@ test_util_memarea(void)
   void *malloced_ptr = NULL;
   int i;
 
-  test_assert(area);
+  tt_assert(area);
 
   p1_orig = p1 = memarea_alloc(area,64);
   p2 = memarea_alloc_zero(area,52);
   p3 = memarea_alloc(area,11);
 
-  test_assert(memarea_owns_ptr(area, p1));
-  test_assert(memarea_owns_ptr(area, p2));
-  test_assert(memarea_owns_ptr(area, p3));
+  tt_assert(memarea_owns_ptr(area, p1));
+  tt_assert(memarea_owns_ptr(area, p2));
+  tt_assert(memarea_owns_ptr(area, p3));
   /* Make sure we left enough space. */
-  test_assert(p1+64 <= p2);
-  test_assert(p2+52 <= p3);
+  tt_assert(p1+64 <= p2);
+  tt_assert(p2+52 <= p3);
   /* Make sure we aligned. */
-  test_eq(((uintptr_t)p1) % sizeof(void*), 0);
-  test_eq(((uintptr_t)p2) % sizeof(void*), 0);
-  test_eq(((uintptr_t)p3) % sizeof(void*), 0);
-  test_assert(!memarea_owns_ptr(area, p3+8192));
-  test_assert(!memarea_owns_ptr(area, p3+30));
-  test_assert(tor_mem_is_zero(p2, 52));
+  tt_int_op(((uintptr_t)p1) % sizeof(void*),==, 0);
+  tt_int_op(((uintptr_t)p2) % sizeof(void*),==, 0);
+  tt_int_op(((uintptr_t)p3) % sizeof(void*),==, 0);
+  tt_assert(!memarea_owns_ptr(area, p3+8192));
+  tt_assert(!memarea_owns_ptr(area, p3+30));
+  tt_assert(tor_mem_is_zero(p2, 52));
   /* Make sure we don't overalign. */
   p1 = memarea_alloc(area, 1);
   p2 = memarea_alloc(area, 1);
-  test_eq_ptr(p1+sizeof(void*), p2);
+  tt_ptr_op(p1+sizeof(void*),==, p2);
   {
     malloced_ptr = tor_malloc(64);
-    test_assert(!memarea_owns_ptr(area, malloced_ptr));
+    tt_assert(!memarea_owns_ptr(area, malloced_ptr));
     tor_free(malloced_ptr);
   }
 
@@ -2164,18 +2164,18 @@ test_util_memarea(void)
     malloced_ptr = tor_malloc(64);
     crypto_rand((char*)malloced_ptr, 64);
     p1 = memarea_memdup(area, malloced_ptr, 64);
-    test_assert(p1 != malloced_ptr);
-    test_memeq(p1, malloced_ptr, 64);
+    tt_assert(p1 != malloced_ptr);
+    tt_mem_op(p1,==, malloced_ptr, 64);
     tor_free(malloced_ptr);
   }
 
   /* memarea_strdup. */
   p1 = memarea_strdup(area,"");
   p2 = memarea_strdup(area, "abcd");
-  test_assert(p1);
-  test_assert(p2);
-  test_streq(p1, "");
-  test_streq(p2, "abcd");
+  tt_assert(p1);
+  tt_assert(p2);
+  tt_str_op(p1,==, "");
+  tt_str_op(p2,==, "abcd");
 
   /* memarea_strndup. */
   {
@@ -2184,33 +2184,33 @@ test_util_memarea(void)
     size_t len = strlen(s);
     p1 = memarea_strndup(area, s, 1000);
     p2 = memarea_strndup(area, s, 10);
-    test_streq(p1, s);
-    test_assert(p2 >= p1 + len + 1);
-    test_memeq(s, p2, 10);
-    test_eq(p2[10], '\0');
+    tt_str_op(p1,==, s);
+    tt_assert(p2 >= p1 + len + 1);
+    tt_mem_op(s,==, p2, 10);
+    tt_int_op(p2[10],==, '\0');
     p3 = memarea_strndup(area, s, len);
-    test_streq(p3, s);
+    tt_str_op(p3,==, s);
     p3 = memarea_strndup(area, s, len-1);
-    test_memeq(s, p3, len-1);
-    test_eq(p3[len-1], '\0');
+    tt_mem_op(s,==, p3, len-1);
+    tt_int_op(p3[len-1],==, '\0');
   }
 
   memarea_clear(area);
   p1 = memarea_alloc(area, 1);
-  test_eq_ptr(p1, p1_orig);
+  tt_ptr_op(p1,==, p1_orig);
   memarea_clear(area);
 
   /* Check for running over an area's size. */
   for (i = 0; i < 512; ++i) {
     p1 = memarea_alloc(area, crypto_rand_int(5)+1);
-    test_assert(memarea_owns_ptr(area, p1));
+    tt_assert(memarea_owns_ptr(area, p1));
   }
   memarea_assert_ok(area);
   /* Make sure we can allocate a too-big object. */
   p1 = memarea_alloc_zero(area, 9000);
   p2 = memarea_alloc_zero(area, 16);
-  test_assert(memarea_owns_ptr(area, p1));
-  test_assert(memarea_owns_ptr(area, p2));
+  tt_assert(memarea_owns_ptr(area, p1));
+  tt_assert(memarea_owns_ptr(area, p2));
 
  done:
   memarea_drop_all(area);
@@ -2229,22 +2229,22 @@ test_util_datadir(void)
   temp_dir = get_datadir_fname(NULL);
   f = get_datadir_fname("state");
   tor_snprintf(buf, sizeof(buf), "%s"PATH_SEPARATOR"state", temp_dir);
-  test_streq(f, buf);
+  tt_str_op(f,==, buf);
   tor_free(f);
   f = get_datadir_fname2("cache", "thingy");
   tor_snprintf(buf, sizeof(buf),
                "%s"PATH_SEPARATOR"cache"PATH_SEPARATOR"thingy", temp_dir);
-  test_streq(f, buf);
+  tt_str_op(f,==, buf);
   tor_free(f);
   f = get_datadir_fname2_suffix("cache", "thingy", ".foo");
   tor_snprintf(buf, sizeof(buf),
                "%s"PATH_SEPARATOR"cache"PATH_SEPARATOR"thingy.foo", temp_dir);
-  test_streq(f, buf);
+  tt_str_op(f,==, buf);
   tor_free(f);
   f = get_datadir_fname_suffix("cache", ".foo");
   tor_snprintf(buf, sizeof(buf), "%s"PATH_SEPARATOR"cache.foo",
                temp_dir);
-  test_streq(f, buf);
+  tt_str_op(f,==, buf);
 
  done:
   tor_free(f);
@@ -2275,8 +2275,8 @@ test_util_strtok(void)
     }
     tor_snprintf(buf, sizeof(buf), "%s", pad1);
     tor_snprintf(buf2, sizeof(buf2), "%s", pad2);
-    test_assert(NULL == tor_strtok_r_impl(buf, " ", &cp1));
-    test_assert(NULL == tor_strtok_r_impl(buf2, ".!..;!", &cp2));
+    tt_assert(NULL == tor_strtok_r_impl(buf, " ", &cp1));
+    tt_assert(NULL == tor_strtok_r_impl(buf2, ".!..;!", &cp2));
 
     tor_snprintf(buf, sizeof(buf),
                  "%sGraved on the dark  in gestures of descent%s", pad1, pad1);
@@ -2284,43 +2284,43 @@ test_util_strtok(void)
                 "%sthey.seemed;;their!.own;most.perfect;monument%s",pad2,pad2);
     /*  -- "Year's End", Richard Wilbur */
 
-    test_streq("Graved", tor_strtok_r_impl(buf, " ", &cp1));
-    test_streq("they", tor_strtok_r_impl(buf2, ".!..;!", &cp2));
+    tt_str_op("Graved",==, tor_strtok_r_impl(buf, " ", &cp1));
+    tt_str_op("they",==, tor_strtok_r_impl(buf2, ".!..;!", &cp2));
 #define S1() tor_strtok_r_impl(NULL, " ", &cp1)
 #define S2() tor_strtok_r_impl(NULL, ".!..;!", &cp2)
-    test_streq("on", S1());
-    test_streq("the", S1());
-    test_streq("dark", S1());
-    test_streq("seemed", S2());
-    test_streq("their", S2());
-    test_streq("own", S2());
-    test_streq("in", S1());
-    test_streq("gestures", S1());
-    test_streq("of", S1());
-    test_streq("most", S2());
-    test_streq("perfect", S2());
-    test_streq("descent", S1());
-    test_streq("monument", S2());
-    test_eq_ptr(NULL, S1());
-    test_eq_ptr(NULL, S2());
+    tt_str_op("on",==, S1());
+    tt_str_op("the",==, S1());
+    tt_str_op("dark",==, S1());
+    tt_str_op("seemed",==, S2());
+    tt_str_op("their",==, S2());
+    tt_str_op("own",==, S2());
+    tt_str_op("in",==, S1());
+    tt_str_op("gestures",==, S1());
+    tt_str_op("of",==, S1());
+    tt_str_op("most",==, S2());
+    tt_str_op("perfect",==, S2());
+    tt_str_op("descent",==, S1());
+    tt_str_op("monument",==, S2());
+    tt_ptr_op(NULL,==, S1());
+    tt_ptr_op(NULL,==, S2());
   }
 
   buf[0] = 0;
-  test_eq_ptr(NULL, tor_strtok_r_impl(buf, " ", &cp1));
-  test_eq_ptr(NULL, tor_strtok_r_impl(buf, "!", &cp1));
+  tt_ptr_op(NULL,==, tor_strtok_r_impl(buf, " ", &cp1));
+  tt_ptr_op(NULL,==, tor_strtok_r_impl(buf, "!", &cp1));
 
   strlcpy(buf, "Howdy!", sizeof(buf));
-  test_streq("Howdy", tor_strtok_r_impl(buf, "!", &cp1));
-  test_eq_ptr(NULL, tor_strtok_r_impl(NULL, "!", &cp1));
+  tt_str_op("Howdy",==, tor_strtok_r_impl(buf, "!", &cp1));
+  tt_ptr_op(NULL,==, tor_strtok_r_impl(NULL, "!", &cp1));
 
   strlcpy(buf, " ", sizeof(buf));
-  test_eq_ptr(NULL, tor_strtok_r_impl(buf, " ", &cp1));
+  tt_ptr_op(NULL,==, tor_strtok_r_impl(buf, " ", &cp1));
   strlcpy(buf, "  ", sizeof(buf));
-  test_eq_ptr(NULL, tor_strtok_r_impl(buf, " ", &cp1));
+  tt_ptr_op(NULL,==, tor_strtok_r_impl(buf, " ", &cp1));
 
   strlcpy(buf, "something  ", sizeof(buf));
-  test_streq("something", tor_strtok_r_impl(buf, " ", &cp1));
-  test_eq_ptr(NULL, tor_strtok_r_impl(NULL, ";", &cp1));
+  tt_str_op("something",==, tor_strtok_r_impl(buf, " ", &cp1));
+  tt_ptr_op(NULL,==, tor_strtok_r_impl(NULL, ";", &cp1));
  done:
   ;
 }
@@ -2340,23 +2340,23 @@ test_util_find_str_at_start_of_line(void *ptr)
 
   (void)ptr;
 
-  test_eq_ptr(long_string, find_str_at_start_of_line(long_string, ""));
-  test_eq_ptr(NULL, find_str_at_start_of_line(short_string, "nonsense"));
-  test_eq_ptr(NULL, find_str_at_start_of_line(long_string, "nonsense"));
-  test_eq_ptr(NULL, find_str_at_start_of_line(long_string, "\n"));
-  test_eq_ptr(NULL, find_str_at_start_of_line(long_string, "how "));
-  test_eq_ptr(NULL, find_str_at_start_of_line(long_string, "kitty"));
-  test_eq_ptr(long_string, find_str_at_start_of_line(long_string, "h"));
-  test_eq_ptr(long_string, find_str_at_start_of_line(long_string, "how"));
-  test_eq_ptr(line2, find_str_at_start_of_line(long_string, "he"));
-  test_eq_ptr(line2, find_str_at_start_of_line(long_string, "hell"));
-  test_eq_ptr(line2, find_str_at_start_of_line(long_string, "hello k"));
-  test_eq_ptr(line2, find_str_at_start_of_line(long_string, "hello kitty\n"));
-  test_eq_ptr(line2, find_str_at_start_of_line(long_string, "hello kitty\nt"));
-  test_eq_ptr(line3, find_str_at_start_of_line(long_string, "third"));
-  test_eq_ptr(line3, find_str_at_start_of_line(long_string, "third line"));
-  test_eq_ptr(NULL,  find_str_at_start_of_line(long_string, "third line\n"));
-  test_eq_ptr(short_line2, find_str_at_start_of_line(short_string,
+  tt_ptr_op(long_string,==, find_str_at_start_of_line(long_string, ""));
+  tt_ptr_op(NULL,==, find_str_at_start_of_line(short_string, "nonsense"));
+  tt_ptr_op(NULL,==, find_str_at_start_of_line(long_string, "nonsense"));
+  tt_ptr_op(NULL,==, find_str_at_start_of_line(long_string, "\n"));
+  tt_ptr_op(NULL,==, find_str_at_start_of_line(long_string, "how "));
+  tt_ptr_op(NULL,==, find_str_at_start_of_line(long_string, "kitty"));
+  tt_ptr_op(long_string,==, find_str_at_start_of_line(long_string, "h"));
+  tt_ptr_op(long_string,==, find_str_at_start_of_line(long_string, "how"));
+  tt_ptr_op(line2,==, find_str_at_start_of_line(long_string, "he"));
+  tt_ptr_op(line2,==, find_str_at_start_of_line(long_string, "hell"));
+  tt_ptr_op(line2,==, find_str_at_start_of_line(long_string, "hello k"));
+  tt_ptr_op(line2,==, find_str_at_start_of_line(long_string, "hello kitty\n"));
+  tt_ptr_op(line2,==, find_str_at_start_of_line(long_string, "hello kitty\nt"));
+  tt_ptr_op(line3,==, find_str_at_start_of_line(long_string, "third"));
+  tt_ptr_op(line3,==, find_str_at_start_of_line(long_string, "third line"));
+  tt_ptr_op(NULL,==,  find_str_at_start_of_line(long_string, "third line\n"));
+  tt_ptr_op(short_line2,==, find_str_at_start_of_line(short_string,
                                                      "second line\n"));
  done:
   ;
@@ -2367,25 +2367,25 @@ test_util_string_is_C_identifier(void *ptr)
 {
   (void)ptr;
 
-  test_eq(1, string_is_C_identifier("string_is_C_identifier"));
-  test_eq(1, string_is_C_identifier("_string_is_C_identifier"));
-  test_eq(1, string_is_C_identifier("_"));
-  test_eq(1, string_is_C_identifier("i"));
-  test_eq(1, string_is_C_identifier("_____"));
-  test_eq(1, string_is_C_identifier("__00__"));
-  test_eq(1, string_is_C_identifier("__init__"));
-  test_eq(1, string_is_C_identifier("_0"));
-  test_eq(1, string_is_C_identifier("_0string_is_C_identifier"));
-  test_eq(1, string_is_C_identifier("_0"));
+  tt_int_op(1,==, string_is_C_identifier("string_is_C_identifier"));
+  tt_int_op(1,==, string_is_C_identifier("_string_is_C_identifier"));
+  tt_int_op(1,==, string_is_C_identifier("_"));
+  tt_int_op(1,==, string_is_C_identifier("i"));
+  tt_int_op(1,==, string_is_C_identifier("_____"));
+  tt_int_op(1,==, string_is_C_identifier("__00__"));
+  tt_int_op(1,==, string_is_C_identifier("__init__"));
+  tt_int_op(1,==, string_is_C_identifier("_0"));
+  tt_int_op(1,==, string_is_C_identifier("_0string_is_C_identifier"));
+  tt_int_op(1,==, string_is_C_identifier("_0"));
 
-  test_eq(0, string_is_C_identifier("0_string_is_C_identifier"));
-  test_eq(0, string_is_C_identifier("0"));
-  test_eq(0, string_is_C_identifier(""));
-  test_eq(0, string_is_C_identifier(";"));
-  test_eq(0, string_is_C_identifier("i;"));
-  test_eq(0, string_is_C_identifier("_;"));
-  test_eq(0, string_is_C_identifier("í"));
-  test_eq(0, string_is_C_identifier("ñ"));
+  tt_int_op(0,==, string_is_C_identifier("0_string_is_C_identifier"));
+  tt_int_op(0,==, string_is_C_identifier("0"));
+  tt_int_op(0,==, string_is_C_identifier(""));
+  tt_int_op(0,==, string_is_C_identifier(";"));
+  tt_int_op(0,==, string_is_C_identifier("i;"));
+  tt_int_op(0,==, string_is_C_identifier("_;"));
+  tt_int_op(0,==, string_is_C_identifier("í"));
+  tt_int_op(0,==, string_is_C_identifier("ñ"));
 
  done:
   ;
@@ -2402,48 +2402,48 @@ test_util_asprintf(void *ptr)
 
   /* simple string */
   r = tor_asprintf(&cp, "simple string 100%% safe");
-  test_assert(cp);
-  test_streq("simple string 100% safe", cp);
-  test_eq(strlen(cp), r);
+  tt_assert(cp);
+  tt_str_op("simple string 100% safe",==, cp);
+  tt_int_op(strlen(cp),==, r);
   tor_free(cp);
 
   /* empty string */
   r = tor_asprintf(&cp, "%s", "");
-  test_assert(cp);
-  test_streq("", cp);
-  test_eq(strlen(cp), r);
+  tt_assert(cp);
+  tt_str_op("",==, cp);
+  tt_int_op(strlen(cp),==, r);
   tor_free(cp);
 
   /* numbers (%i) */
   r = tor_asprintf(&cp, "I like numbers-%2i, %i, etc.", -1, 2);
-  test_assert(cp);
-  test_streq("I like numbers--1, 2, etc.", cp);
-  test_eq(strlen(cp), r);
+  tt_assert(cp);
+  tt_str_op("I like numbers--1, 2, etc.",==, cp);
+  tt_int_op(strlen(cp),==, r);
   /* don't free cp; next test uses it. */
 
   /* numbers (%d) */
   r = tor_asprintf(&cp2, "First=%d, Second=%d", 101, 202);
-  test_assert(cp2);
-  test_eq(strlen(cp2), r);
-  test_streq("First=101, Second=202", cp2);
-  test_assert(cp != cp2);
+  tt_assert(cp2);
+  tt_int_op(strlen(cp2),==, r);
+  tt_str_op("First=101, Second=202",==, cp2);
+  tt_assert(cp != cp2);
   tor_free(cp);
   tor_free(cp2);
 
   /* Glass-box test: a string exactly 128 characters long. */
   r = tor_asprintf(&cp, "Lorem1: %sLorem2: %s", LOREMIPSUM, LOREMIPSUM);
-  test_assert(cp);
-  test_eq(128, r);
-  test_assert(cp[128] == '\0');
-  test_streq("Lorem1: "LOREMIPSUM"Lorem2: "LOREMIPSUM, cp);
+  tt_assert(cp);
+  tt_int_op(128,==, r);
+  tt_int_op(cp[128], ==, '\0');
+  tt_str_op("Lorem1: "LOREMIPSUM"Lorem2: "LOREMIPSUM,==, cp);
   tor_free(cp);
 
   /* String longer than 128 characters */
   r = tor_asprintf(&cp, "1: %s 2: %s 3: %s",
                    LOREMIPSUM, LOREMIPSUM, LOREMIPSUM);
-  test_assert(cp);
-  test_eq(strlen(cp), r);
-  test_streq("1: "LOREMIPSUM" 2: "LOREMIPSUM" 3: "LOREMIPSUM, cp);
+  tt_assert(cp);
+  tt_int_op(strlen(cp),==, r);
+  tt_str_op("1: "LOREMIPSUM" 2: "LOREMIPSUM" 3: "LOREMIPSUM,==, cp);
 
  done:
   tor_free(cp);
@@ -2464,9 +2464,9 @@ test_util_listdir(void *ptr)
   dir1   = tor_strdup(get_fname("some-directory"));
   dirname = tor_strdup(get_fname(NULL));
 
-  test_eq(0, write_str_to_file(fname1, "X\n", 0));
-  test_eq(0, write_str_to_file(fname2, "Y\n", 0));
-  test_eq(0, write_str_to_file(fname3, "Z\n", 0));
+  tt_int_op(0,==, write_str_to_file(fname1, "X\n", 0));
+  tt_int_op(0,==, write_str_to_file(fname2, "Y\n", 0));
+  tt_int_op(0,==, write_str_to_file(fname3, "Z\n", 0));
 #ifdef _WIN32
   r = mkdir(dir1);
 #else
@@ -2479,15 +2479,15 @@ test_util_listdir(void *ptr)
   }
 
   dir_contents = tor_listdir(dirname);
-  test_assert(dir_contents);
+  tt_assert(dir_contents);
   /* make sure that each filename is listed. */
-  test_assert(smartlist_contains_string_case(dir_contents, "hopscotch"));
-  test_assert(smartlist_contains_string_case(dir_contents, "mumblety-peg"));
-  test_assert(smartlist_contains_string_case(dir_contents, ".hidden-file"));
-  test_assert(smartlist_contains_string_case(dir_contents, "some-directory"));
+  tt_assert(smartlist_contains_string_case(dir_contents, "hopscotch"));
+  tt_assert(smartlist_contains_string_case(dir_contents, "mumblety-peg"));
+  tt_assert(smartlist_contains_string_case(dir_contents, ".hidden-file"));
+  tt_assert(smartlist_contains_string_case(dir_contents, "some-directory"));
 
-  test_assert(!smartlist_contains_string(dir_contents, "."));
-  test_assert(!smartlist_contains_string(dir_contents, ".."));
+  tt_assert(!smartlist_contains_string(dir_contents, "."));
+  tt_assert(!smartlist_contains_string(dir_contents, ".."));
 
  done:
   tor_free(fname1);
@@ -2627,53 +2627,53 @@ test_util_exit_status(void *ptr)
   (void)ptr;
 
   clear_hex_errno(hex_errno);
-  test_streq("", hex_errno);
+  tt_str_op("",==, hex_errno);
 
   clear_hex_errno(hex_errno);
   n = format_helper_exit_status(0, 0, hex_errno);
-  test_streq("0/0\n", hex_errno);
-  test_eq(n, strlen(hex_errno));
+  tt_str_op("0/0\n",==, hex_errno);
+  tt_int_op(n,==, strlen(hex_errno));
 
 #if SIZEOF_INT == 4
 
   clear_hex_errno(hex_errno);
   n = format_helper_exit_status(0, 0x7FFFFFFF, hex_errno);
-  test_streq("0/7FFFFFFF\n", hex_errno);
-  test_eq(n, strlen(hex_errno));
+  tt_str_op("0/7FFFFFFF\n",==, hex_errno);
+  tt_int_op(n,==, strlen(hex_errno));
 
   clear_hex_errno(hex_errno);
   n = format_helper_exit_status(0xFF, -0x80000000, hex_errno);
-  test_streq("FF/-80000000\n", hex_errno);
-  test_eq(n, strlen(hex_errno));
-  test_eq(n, HEX_ERRNO_SIZE);
+  tt_str_op("FF/-80000000\n",==, hex_errno);
+  tt_int_op(n,==, strlen(hex_errno));
+  tt_int_op(n,==, HEX_ERRNO_SIZE);
 
 #elif SIZEOF_INT == 8
 
   clear_hex_errno(hex_errno);
   n = format_helper_exit_status(0, 0x7FFFFFFFFFFFFFFF, hex_errno);
-  test_streq("0/7FFFFFFFFFFFFFFF\n", hex_errno);
-  test_eq(n, strlen(hex_errno));
+  tt_str_op("0/7FFFFFFFFFFFFFFF\n",==, hex_errno);
+  tt_int_op(n,==, strlen(hex_errno));
 
   clear_hex_errno(hex_errno);
   n = format_helper_exit_status(0xFF, -0x8000000000000000, hex_errno);
-  test_streq("FF/-8000000000000000\n", hex_errno);
-  test_eq(n, strlen(hex_errno));
-  test_eq(n, HEX_ERRNO_SIZE);
+  tt_str_op("FF/-8000000000000000\n",==, hex_errno);
+  tt_int_op(n,==, strlen(hex_errno));
+  tt_int_op(n,==, HEX_ERRNO_SIZE);
 
 #endif
 
   clear_hex_errno(hex_errno);
   n = format_helper_exit_status(0x7F, 0, hex_errno);
-  test_streq("7F/0\n", hex_errno);
-  test_eq(n, strlen(hex_errno));
+  tt_str_op("7F/0\n",==, hex_errno);
+  tt_int_op(n,==, strlen(hex_errno));
 
   clear_hex_errno(hex_errno);
   n = format_helper_exit_status(0x08, -0x242, hex_errno);
-  test_streq("8/-242\n", hex_errno);
-  test_eq(n, strlen(hex_errno));
+  tt_str_op("8/-242\n",==, hex_errno);
+  tt_int_op(n,==, strlen(hex_errno));
 
   clear_hex_errno(hex_errno);
-  test_streq("", hex_errno);
+  tt_str_op("",==, hex_errno);
 
  done:
   ;
@@ -2822,14 +2822,14 @@ run_util_spawn_background(const char *argv[], const char *expected_out,
 
   notify_pending_waitpid_callbacks();
 
-  test_eq(expected_status, status);
+  tt_int_op(expected_status,==, status);
   if (status == PROCESS_STATUS_ERROR) {
     tt_ptr_op(process_handle, ==, NULL);
     return;
   }
 
-  test_assert(process_handle != NULL);
-  test_eq(expected_status, process_handle->status);
+  tt_assert(process_handle != NULL);
+  tt_int_op(expected_status,==, process_handle->status);
 
 #ifndef _WIN32
   notify_pending_waitpid_callbacks();
@@ -2837,11 +2837,11 @@ run_util_spawn_background(const char *argv[], const char *expected_out,
 #endif
 
 #ifdef _WIN32
-  test_assert(process_handle->stdout_pipe != INVALID_HANDLE_VALUE);
-  test_assert(process_handle->stderr_pipe != INVALID_HANDLE_VALUE);
+  tt_assert(process_handle->stdout_pipe != INVALID_HANDLE_VALUE);
+  tt_assert(process_handle->stderr_pipe != INVALID_HANDLE_VALUE);
 #else
-  test_assert(process_handle->stdout_pipe >= 0);
-  test_assert(process_handle->stderr_pipe >= 0);
+  tt_assert(process_handle->stdout_pipe >= 0);
+  tt_assert(process_handle->stderr_pipe >= 0);
 #endif
 
   /* Check stdout */
@@ -2849,15 +2849,15 @@ run_util_spawn_background(const char *argv[], const char *expected_out,
                                          sizeof(stdout_buf) - 1);
   tt_assert(pos >= 0);
   stdout_buf[pos] = '\0';
-  test_eq(strlen(expected_out), pos);
-  test_streq(expected_out, stdout_buf);
+  tt_int_op(strlen(expected_out),==, pos);
+  tt_str_op(expected_out,==, stdout_buf);
 
   notify_pending_waitpid_callbacks();
 
   /* Check it terminated correctly */
   retval = tor_get_exit_code(process_handle, 1, &exit_code);
-  test_eq(PROCESS_EXIT_EXITED, retval);
-  test_eq(expected_exit, exit_code);
+  tt_int_op(PROCESS_EXIT_EXITED,==, retval);
+  tt_int_op(expected_exit,==, exit_code);
   // TODO: Make test-child exit with something other than 0
 
 #ifndef _WIN32
@@ -2868,10 +2868,10 @@ run_util_spawn_background(const char *argv[], const char *expected_out,
   /* Check stderr */
   pos = tor_read_all_from_process_stderr(process_handle, stderr_buf,
                                          sizeof(stderr_buf) - 1);
-  test_assert(pos >= 0);
+  tt_assert(pos >= 0);
   stderr_buf[pos] = '\0';
-  test_streq(expected_err, stderr_buf);
-  test_eq(strlen(expected_err), pos);
+  tt_str_op(expected_err,==, stderr_buf);
+  tt_int_op(strlen(expected_err),==, pos);
 
   notify_pending_waitpid_callbacks();
 
@@ -2960,9 +2960,9 @@ test_util_spawn_background_partial_read_impl(int exit_early)
 #else
   status = tor_spawn_background(argv[0], argv, NULL, &process_handle);
 #endif
-  test_eq(expected_status, status);
-  test_assert(process_handle);
-  test_eq(expected_status, process_handle->status);
+  tt_int_op(expected_status,==, status);
+  tt_assert(process_handle);
+  tt_int_op(expected_status,==, process_handle->status);
 
   /* Check stdout */
   for (expected_out_ctr = 0; expected_out[expected_out_ctr] != NULL;) {
@@ -2971,7 +2971,7 @@ test_util_spawn_background_partial_read_impl(int exit_early)
                               sizeof(stdout_buf) - 1, NULL);
 #else
     /* Check that we didn't read the end of file last time */
-    test_assert(!eof);
+    tt_assert(!eof);
     pos = tor_read_all_handle(process_handle->stdout_handle, stdout_buf,
                               sizeof(stdout_buf) - 1, NULL, &eof);
 #endif
@@ -2981,10 +2981,10 @@ test_util_spawn_background_partial_read_impl(int exit_early)
     if (0 == pos)
       continue;
 
-    test_assert(pos > 0);
+    tt_assert(pos > 0);
     stdout_buf[pos] = '\0';
-    test_streq(expected_out[expected_out_ctr], stdout_buf);
-    test_eq(strlen(expected_out[expected_out_ctr]), pos);
+    tt_str_op(expected_out[expected_out_ctr],==, stdout_buf);
+    tt_int_op(strlen(expected_out[expected_out_ctr]),==, pos);
     expected_out_ctr++;
   }
 
@@ -2999,33 +2999,33 @@ test_util_spawn_background_partial_read_impl(int exit_early)
   pos = tor_read_all_handle(process_handle->stdout_pipe, stdout_buf,
                             sizeof(stdout_buf) - 1,
                             process_handle);
-  test_eq(0, pos);
+  tt_int_op(0,==, pos);
 #else
   if (!eof) {
     /* We should have got all the data, but maybe not the EOF flag */
     pos = tor_read_all_handle(process_handle->stdout_handle, stdout_buf,
                               sizeof(stdout_buf) - 1,
                               process_handle, &eof);
-    test_eq(0, pos);
-    test_assert(eof);
+    tt_int_op(0,==, pos);
+    tt_assert(eof);
   }
   /* Otherwise, we got the EOF on the last read */
 #endif
 
   /* Check it terminated correctly */
   retval = tor_get_exit_code(process_handle, 1, &exit_code);
-  test_eq(PROCESS_EXIT_EXITED, retval);
-  test_eq(expected_exit, exit_code);
+  tt_int_op(PROCESS_EXIT_EXITED,==, retval);
+  tt_int_op(expected_exit,==, exit_code);
 
   // TODO: Make test-child exit with something other than 0
 
   /* Check stderr */
   pos = tor_read_all_from_process_stderr(process_handle, stderr_buf,
                                          sizeof(stderr_buf) - 1);
-  test_assert(pos >= 0);
+  tt_assert(pos >= 0);
   stderr_buf[pos] = '\0';
-  test_streq(expected_err, stderr_buf);
-  test_eq(strlen(expected_err), pos);
+  tt_str_op(expected_err,==, stderr_buf);
+  tt_int_op(strlen(expected_err),==, pos);
 
  done:
   tor_process_handle_destroy(process_handle, 1);
@@ -3130,15 +3130,15 @@ test_util_format_hex_number(void *ptr)
 
   for (i = 0; test_data[i].str != NULL; ++i) {
     len = format_hex_number_sigsafe(test_data[i].x, buf, sizeof(buf));
-    test_neq(len, 0);
-    test_eq(len, strlen(buf));
-    test_streq(buf, test_data[i].str);
+    tt_int_op(len,!=, 0);
+    tt_int_op(len,==, strlen(buf));
+    tt_str_op(buf,==, test_data[i].str);
   }
 
-  test_eq(4, format_hex_number_sigsafe(0xffff, buf, 5));
-  test_streq(buf, "FFFF");
-  test_eq(0, format_hex_number_sigsafe(0xffff, buf, 4));
-  test_eq(0, format_hex_number_sigsafe(0, buf, 1));
+  tt_int_op(4,==, format_hex_number_sigsafe(0xffff, buf, 5));
+  tt_str_op(buf,==, "FFFF");
+  tt_int_op(0,==, format_hex_number_sigsafe(0xffff, buf, 4));
+  tt_int_op(0,==, format_hex_number_sigsafe(0, buf, 1));
 
  done:
   return;
@@ -3174,21 +3174,21 @@ test_util_format_dec_number(void *ptr)
 
   for (i = 0; test_data[i].str != NULL; ++i) {
     len = format_dec_number_sigsafe(test_data[i].x, buf, sizeof(buf));
-    test_neq(len, 0);
-    test_eq(len, strlen(buf));
-    test_streq(buf, test_data[i].str);
+    tt_int_op(len,!=, 0);
+    tt_int_op(len,==, strlen(buf));
+    tt_str_op(buf,==, test_data[i].str);
 
     len = format_dec_number_sigsafe(test_data[i].x, buf,
                                     (int)(strlen(test_data[i].str) + 1));
-    test_eq(len, strlen(buf));
-    test_streq(buf, test_data[i].str);
+    tt_int_op(len,==, strlen(buf));
+    tt_str_op(buf,==, test_data[i].str);
   }
 
-  test_eq(4, format_dec_number_sigsafe(7331, buf, 5));
-  test_streq(buf, "7331");
-  test_eq(0, format_dec_number_sigsafe(7331, buf, 4));
-  test_eq(1, format_dec_number_sigsafe(0, buf, 2));
-  test_eq(0, format_dec_number_sigsafe(0, buf, 1));
+  tt_int_op(4,==, format_dec_number_sigsafe(7331, buf, 5));
+  tt_str_op(buf,==, "7331");
+  tt_int_op(0,==, format_dec_number_sigsafe(7331, buf, 4));
+  tt_int_op(1,==, format_dec_number_sigsafe(0, buf, 2));
+  tt_int_op(0,==, format_dec_number_sigsafe(0, buf, 1));
 
  done:
   return;
@@ -3237,7 +3237,7 @@ test_util_join_win_cmdline(void *ptr)
   for (i=0; cmdlines[i]!=NULL; i++) {
     log_info(LD_GENERAL, "Joining argvs[%d], expecting <%s>", i, cmdlines[i]);
     joined_argv = tor_join_win_cmdline(argvs[i]);
-    test_streq(cmdlines[i], joined_argv);
+    tt_str_op(cmdlines[i],==, joined_argv);
     tor_free(joined_argv);
   }
 
@@ -3292,17 +3292,17 @@ test_util_split_lines(void *ptr)
              i, tests[i].orig_length);
     SMARTLIST_FOREACH_BEGIN(sl, const char *, line) {
       /* Check we have not got too many lines */
-      test_assert(j < MAX_SPLIT_LINE_COUNT);
+      tt_int_op(MAX_SPLIT_LINE_COUNT, >, j);
       /* Check that there actually should be a line here */
-      test_assert(tests[i].split_line[j] != NULL);
+      tt_assert(tests[i].split_line[j] != NULL);
       log_info(LD_GENERAL, "Line %d of test %d, should be <%s>",
                j, i, tests[i].split_line[j]);
       /* Check that the line is as expected */
-      test_streq(line, tests[i].split_line[j]);
+      tt_str_op(line,==, tests[i].split_line[j]);
       j++;
     } SMARTLIST_FOREACH_END(line);
     /* Check that we didn't miss some lines */
-    test_eq_ptr(NULL, tests[i].split_line[j]);
+    tt_ptr_op(NULL,==, tests[i].split_line[j]);
     tor_free(orig_line);
     smartlist_free(sl);
     sl = NULL;
@@ -3337,7 +3337,7 @@ test_util_di_ops(void)
   for (i = 0; examples[i].a; ++i) {
     size_t len = strlen(examples[i].a);
     int eq1, eq2, neq1, neq2, cmp1, cmp2;
-    test_eq(len, strlen(examples[i].b));
+    tt_int_op(len,==, strlen(examples[i].b));
     /* We do all of the operations, with operands in both orders. */
     eq1 = tor_memeq(examples[i].a, examples[i].b, len);
     eq2 = tor_memeq(examples[i].b, examples[i].a, len);
@@ -3348,18 +3348,18 @@ test_util_di_ops(void)
 
     /* Check for correctness of cmp1 */
     if (cmp1 < 0 && examples[i].want_sign != LT)
-      test_fail();
+      TT_DIE(("Assertion failed."));
     else if (cmp1 > 0 && examples[i].want_sign != GT)
-      test_fail();
+      TT_DIE(("Assertion failed."));
     else if (cmp1 == 0 && examples[i].want_sign != EQ)
-      test_fail();
+      TT_DIE(("Assertion failed."));
 
     /* Check for consistency of everything else with cmp1 */
-    test_eq(eq1, eq2);
-    test_eq(neq1, neq2);
-    test_eq(cmp1, -cmp2);
-    test_eq(eq1, cmp1 == 0);
-    test_eq(neq1, !eq1);
+    tt_int_op(eq1,==, eq2);
+    tt_int_op(neq1,==, neq2);
+    tt_int_op(cmp1,==, -cmp2);
+    tt_int_op(eq1,==, cmp1 == 0);
+    tt_int_op(neq1,==, !eq1);
   }
 
   {
@@ -3374,9 +3374,9 @@ test_util_di_ops(void)
       for (i = 0; i < 256; i++) {
         ii = (uint8_t)i;
         zz = (uint8_t)z;
-        test_eq(tor_memeq(&zz, &ii, 1), zz == ii);
-        test_eq(tor_memcmp(&zz, &ii, 1) > 0 ? GT : EQ, zz > ii ? GT : EQ);
-        test_eq(tor_memcmp(&ii, &zz, 1) < 0 ? LT : EQ, ii < zz ? LT : EQ);
+        tt_int_op(tor_memeq(&zz, &ii, 1),==, zz == ii);
+        tt_int_op(tor_memcmp(&zz, &ii, 1) > 0 ? GT : EQ,==, zz > ii ? GT : EQ);
+        tt_int_op(tor_memcmp(&ii, &zz, 1) < 0 ? LT : EQ,==, ii < zz ? LT : EQ);
       }
     }
   }
@@ -3402,12 +3402,12 @@ static void
 test_util_n_bits_set(void *ptr)
 {
   (void)ptr;
-  test_eq(0, n_bits_set_u8(0));
-  test_eq(1, n_bits_set_u8(1));
-  test_eq(3, n_bits_set_u8(7));
-  test_eq(1, n_bits_set_u8(8));
-  test_eq(2, n_bits_set_u8(129));
-  test_eq(8, n_bits_set_u8(255));
+  tt_int_op(0,==, n_bits_set_u8(0));
+  tt_int_op(1,==, n_bits_set_u8(1));
+  tt_int_op(3,==, n_bits_set_u8(7));
+  tt_int_op(1,==, n_bits_set_u8(8));
+  tt_int_op(2,==, n_bits_set_u8(129));
+  tt_int_op(8,==, n_bits_set_u8(255));
  done:
   ;
 }
@@ -3428,78 +3428,78 @@ test_util_eat_whitespace(void *ptr)
   strlcpy(str, "fuubaar", sizeof(str));
   for (i = 0; i < sizeof(ws); ++i) {
     str[0] = ws[i];
-    test_eq_ptr(str + 1, eat_whitespace(str));
-    test_eq_ptr(str + 1, eat_whitespace_eos(str, str + strlen(str)));
-    test_eq_ptr(str + 1, eat_whitespace_no_nl(str));
-    test_eq_ptr(str + 1, eat_whitespace_eos_no_nl(str, str + strlen(str)));
+    tt_ptr_op(str + 1,==, eat_whitespace(str));
+    tt_ptr_op(str + 1,==, eat_whitespace_eos(str, str + strlen(str)));
+    tt_ptr_op(str + 1,==, eat_whitespace_no_nl(str));
+    tt_ptr_op(str + 1,==, eat_whitespace_eos_no_nl(str, str + strlen(str)));
   }
   str[0] = '\n';
-  test_eq_ptr(str + 1, eat_whitespace(str));
-  test_eq_ptr(str + 1, eat_whitespace_eos(str, str + strlen(str)));
-  test_eq_ptr(str,     eat_whitespace_no_nl(str));
-  test_eq_ptr(str,     eat_whitespace_eos_no_nl(str, str + strlen(str)));
+  tt_ptr_op(str + 1,==, eat_whitespace(str));
+  tt_ptr_op(str + 1,==, eat_whitespace_eos(str, str + strlen(str)));
+  tt_ptr_op(str,==,     eat_whitespace_no_nl(str));
+  tt_ptr_op(str,==,     eat_whitespace_eos_no_nl(str, str + strlen(str)));
 
   /* Empty string */
   strlcpy(str, "", sizeof(str));
-  test_eq_ptr(str, eat_whitespace(str));
-  test_eq_ptr(str, eat_whitespace_eos(str, str));
-  test_eq_ptr(str, eat_whitespace_no_nl(str));
-  test_eq_ptr(str, eat_whitespace_eos_no_nl(str, str));
+  tt_ptr_op(str,==, eat_whitespace(str));
+  tt_ptr_op(str,==, eat_whitespace_eos(str, str));
+  tt_ptr_op(str,==, eat_whitespace_no_nl(str));
+  tt_ptr_op(str,==, eat_whitespace_eos_no_nl(str, str));
 
   /* Only ws */
   strlcpy(str, " \t\r\n", sizeof(str));
-  test_eq_ptr(str + strlen(str), eat_whitespace(str));
-  test_eq_ptr(str + strlen(str), eat_whitespace_eos(str, str + strlen(str)));
-  test_eq_ptr(str + strlen(str) - 1,
+  tt_ptr_op(str + strlen(str),==, eat_whitespace(str));
+  tt_ptr_op(str + strlen(str),==, eat_whitespace_eos(str, str + strlen(str)));
+  tt_ptr_op(str + strlen(str) - 1,==,
               eat_whitespace_no_nl(str));
-  test_eq_ptr(str + strlen(str) - 1,
+  tt_ptr_op(str + strlen(str) - 1,==,
               eat_whitespace_eos_no_nl(str, str + strlen(str)));
 
   strlcpy(str, " \t\r ", sizeof(str));
-  test_eq_ptr(str + strlen(str), eat_whitespace(str));
-  test_eq_ptr(str + strlen(str),
+  tt_ptr_op(str + strlen(str),==, eat_whitespace(str));
+  tt_ptr_op(str + strlen(str),==,
               eat_whitespace_eos(str, str + strlen(str)));
-  test_eq_ptr(str + strlen(str), eat_whitespace_no_nl(str));
-  test_eq_ptr(str + strlen(str),
+  tt_ptr_op(str + strlen(str),==, eat_whitespace_no_nl(str));
+  tt_ptr_op(str + strlen(str),==,
               eat_whitespace_eos_no_nl(str, str + strlen(str)));
 
   /* Multiple ws */
   strlcpy(str, "fuubaar", sizeof(str));
   for (i = 0; i < sizeof(ws); ++i)
     str[i] = ws[i];
-  test_eq_ptr(str + sizeof(ws), eat_whitespace(str));
-  test_eq_ptr(str + sizeof(ws), eat_whitespace_eos(str, str + strlen(str)));
-  test_eq_ptr(str + sizeof(ws), eat_whitespace_no_nl(str));
-  test_eq_ptr(str + sizeof(ws),
+  tt_ptr_op(str + sizeof(ws),==, eat_whitespace(str));
+  tt_ptr_op(str + sizeof(ws),==, eat_whitespace_eos(str, str + strlen(str)));
+  tt_ptr_op(str + sizeof(ws),==, eat_whitespace_no_nl(str));
+  tt_ptr_op(str + sizeof(ws),==,
               eat_whitespace_eos_no_nl(str, str + strlen(str)));
 
   /* Eat comment */
   strlcpy(str, "# Comment \n No Comment", sizeof(str));
-  test_streq("No Comment", eat_whitespace(str));
-  test_streq("No Comment", eat_whitespace_eos(str, str + strlen(str)));
-  test_eq_ptr(str, eat_whitespace_no_nl(str));
-  test_eq_ptr(str, eat_whitespace_eos_no_nl(str, str + strlen(str)));
+  tt_str_op("No Comment",==, eat_whitespace(str));
+  tt_str_op("No Comment",==, eat_whitespace_eos(str, str + strlen(str)));
+  tt_ptr_op(str,==, eat_whitespace_no_nl(str));
+  tt_ptr_op(str,==, eat_whitespace_eos_no_nl(str, str + strlen(str)));
 
   /* Eat comment & ws mix */
   strlcpy(str, " # \t Comment \n\t\nNo Comment", sizeof(str));
-  test_streq("No Comment", eat_whitespace(str));
-  test_streq("No Comment", eat_whitespace_eos(str, str + strlen(str)));
-  test_eq_ptr(str + 1, eat_whitespace_no_nl(str));
-  test_eq_ptr(str + 1, eat_whitespace_eos_no_nl(str, str + strlen(str)));
+  tt_str_op("No Comment",==, eat_whitespace(str));
+  tt_str_op("No Comment",==, eat_whitespace_eos(str, str + strlen(str)));
+  tt_ptr_op(str + 1,==, eat_whitespace_no_nl(str));
+  tt_ptr_op(str + 1,==, eat_whitespace_eos_no_nl(str, str + strlen(str)));
 
   /* Eat entire comment */
   strlcpy(str, "#Comment", sizeof(str));
-  test_eq_ptr(str + strlen(str), eat_whitespace(str));
-  test_eq_ptr(str + strlen(str), eat_whitespace_eos(str, str + strlen(str)));
-  test_eq_ptr(str, eat_whitespace_no_nl(str));
-  test_eq_ptr(str, eat_whitespace_eos_no_nl(str, str + strlen(str)));
+  tt_ptr_op(str + strlen(str),==, eat_whitespace(str));
+  tt_ptr_op(str + strlen(str),==, eat_whitespace_eos(str, str + strlen(str)));
+  tt_ptr_op(str,==, eat_whitespace_no_nl(str));
+  tt_ptr_op(str,==, eat_whitespace_eos_no_nl(str, str + strlen(str)));
 
   /* Blank line, then comment */
   strlcpy(str, " \t\n # Comment", sizeof(str));
-  test_eq_ptr(str + strlen(str), eat_whitespace(str));
-  test_eq_ptr(str + strlen(str), eat_whitespace_eos(str, str + strlen(str)));
-  test_eq_ptr(str + 2, eat_whitespace_no_nl(str));
-  test_eq_ptr(str + 2, eat_whitespace_eos_no_nl(str, str + strlen(str)));
+  tt_ptr_op(str + strlen(str),==, eat_whitespace(str));
+  tt_ptr_op(str + strlen(str),==, eat_whitespace_eos(str, str + strlen(str)));
+  tt_ptr_op(str + 2,==, eat_whitespace_no_nl(str));
+  tt_ptr_op(str + 2,==, eat_whitespace_eos_no_nl(str, str + strlen(str)));
 
  done:
   ;
@@ -3827,12 +3827,12 @@ test_util_round_to_next_multiple_of(void *arg)
 {
   (void)arg;
 
-  test_assert(round_uint64_to_next_multiple_of(0,1) == 0);
-  test_assert(round_uint64_to_next_multiple_of(0,7) == 0);
+  tt_assert(round_uint64_to_next_multiple_of(0,1) == 0);
+  tt_assert(round_uint64_to_next_multiple_of(0,7) == 0);
 
-  test_assert(round_uint64_to_next_multiple_of(99,1) == 99);
-  test_assert(round_uint64_to_next_multiple_of(99,7) == 105);
-  test_assert(round_uint64_to_next_multiple_of(99,9) == 99);
+  tt_assert(round_uint64_to_next_multiple_of(99,1) == 99);
+  tt_assert(round_uint64_to_next_multiple_of(99,7) == 105);
+  tt_assert(round_uint64_to_next_multiple_of(99,9) == 99);
 
  done:
   ;