Use coccinelle scripts to clean up our unit tests

This should get rid of most of the users of the old test_*
functions.  Some are in macros and will need manual cleanup, though.

This patch is for 13119, and was automatically generated with these
scripts.  The perl scripts are there because coccinelle hates
operators as macro arguments.

------------------------------

s/==,/_X_EQ_,/g;
s/!=,/_X_NE_,/g;
s/<,/_X_LT_,/g;
s/>,/_X_GT_,/g;
s/>=,/_X_GEQ_,/g;
s/<=,/_X_LEQ_,/g;

------------------------------
@@
expression a;
identifier func;
@@
 func (...) {
<...
-test_fail_msg
+TT_DIE
 (
+(
 a
+)
 )
 ...>
 }

@@
identifier func;
@@
 func (...) {
<...
-test_fail()
+TT_DIE(("Assertion failed."))
 ...>
 }

@@
expression a;
identifier func;
@@
 func (...) {
<...
-test_assert
+tt_assert
	(a)
 ...>
 }

@@
expression a, b;
identifier func;
@@
 func (...) {
<...
-test_eq
+tt_int_op
 (a,
+_X_EQ_,
  b)
 ...>
 }

@@
expression a, b;
identifier func;
@@
 func (...) {
<...
-test_neq
+tt_int_op
 (a,
+_X_NEQ_,
  b)
 ...>
 }

@@
expression a, b;
identifier func;
@@
 func (...) {
<...
-test_streq
+tt_str_op
 (a,
+_X_EQ_,
  b)
 ...>
 }

@@
expression a, b;
identifier func;
@@
 func (...) {
<...
-test_strneq
+tt_str_op
 (a,
+_X_NEQ_,
  b)
 ...>
 }

@@
expression a, b;
identifier func;
@@
 func (...) {
<...
-test_eq_ptr
+tt_ptr_op
 (a,
+_X_EQ_,
  b)
 ...>
 }

@@
expression a, b;
identifier func;
@@
 func() {
<...
-test_neq_ptr
+tt_ptr_op
 (a,
+_X_NEQ_,
  b)
 ...>
 }

@@
expression a, b, len;
identifier func;
@@
 func (...) {
<...
-test_memeq
+tt_mem_op
 (a,
+_X_EQ_,
  b, len)
 ...>
 }

@@
expression a, b, len;
identifier func;
@@
 func (...) {
<...
-test_memneq
+tt_mem_op
 (a,
+_X_NEQ_,
  b, len)
 ...>
 }

------------------------------
@@
char a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a == b
+a, _X_EQ_, b
 )
 ...>
}

@@
int a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a == b
+a, _X_EQ_, b
 )
 ...>
}

@@
long a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a == b
+a, _X_EQ_, b
 )
 ...>
}

@@
unsigned int a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_uint_op
 (
-a == b
+a, _X_EQ_, b
 )
 ...>
}

@@
unsigned long a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_uint_op
 (
-a == b
+a, _X_EQ_, b
 )
 ...>
}

@@
char a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a != b
+a, _X_NEQ_, b
 )
 ...>
}

@@
int a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a != b
+a, _X_NEQ_, b
 )
 ...>
}

@@
long a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a != b
+a, _X_NEQ_, b
 )
 ...>
}

@@
unsigned int a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_uint_op
 (
-a != b
+a, _X_NEQ_, b
 )
 ...>
}

@@
unsigned long a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_uint_op
 (
-a != b
+a, _X_NEQ_, b
 )
 ...>
}

@@
char a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a >= b
+a, _X_GEQ_, b
 )
 ...>
}

@@
int a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a >= b
+a, _X_GEQ_, b
 )
 ...>
}

@@
long a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a >= b
+a, _X_GEQ_, b
 )
 ...>
}

@@
unsigned int a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_uint_op
 (
-a >= b
+a, _X_GEQ_, b
 )
 ...>
}

@@
unsigned long a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_uint_op
 (
-a >= b
+a, _X_GEQ_, b
 )
 ...>
}

@@
char a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a <= b
+a, _X_LEQ_, b
 )
 ...>
}

@@
int a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a <= b
+a, _X_LEQ_, b
 )
 ...>
}

@@
long a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a <= b
+a, _X_LEQ_, b
 )
 ...>
}

@@
unsigned int a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_uint_op
 (
-a <= b
+a, _X_LEQ_, b
 )
 ...>
}

@@
unsigned long a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_uint_op
 (
-a <= b
+a, _X_LEQ_, b
 )
 ...>
}

@@
char a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a > b
+a, _X_GT_, b
 )
 ...>
}

@@
int a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a > b
+a, _X_GT_, b
 )
 ...>
}

@@
long a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a > b
+a, _X_GT_, b
 )
 ...>
}

@@
unsigned int a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_uint_op
 (
-a > b
+a, _X_GT_, b
 )
 ...>
}

@@
unsigned long a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_uint_op
 (
-a > b
+a, _X_GT_, b
 )
 ...>
}

@@
char a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a < b
+a, _X_LT_, b
 )
 ...>
}

@@
int a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a < b
+a, _X_LT_, b
 )
 ...>
}

@@
long a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_int_op
 (
-a < b
+a, _X_LT_, b
 )
 ...>
}

@@
unsigned int a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_uint_op
 (
-a < b
+a, _X_LT_, b
 )
 ...>
}

@@
unsigned long a, b;
identifier func;
@@
 func (...) {
<...
-tt_assert
+tt_uint_op
 (
-a < b
+a, _X_LT_, b
 )
 ...>
}

------------------------------

s/_X_NEQ_/!=/g;
s/_X_NE_/!=/g;
s/_X_EQ_/==/g;
s/_X_GT_/>/g;
s/_X_LT_/</g;
s/_X_GEQ_/>=/g;
s/_X_LEQ_/<=/g;

s/test_mem_op\(/tt_mem_op\(/g;

1 files changed, 222 insertions, 222 deletions

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. */