[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[tor-commits] [tor/master] Replace operators used as macro arguments with OP_XX macros



commit a3dafd3f58bb3122b9de919e931c02b5e12373b2
Author: Nick Mathewson <nickm@xxxxxxxxxxxxxx>
Date:   Wed Nov 12 13:28:07 2014 -0500

    Replace operators used as macro arguments with OP_XX macros
    
    Part of fix for 13172
---
 src/common/compat_libevent.c      |    2 +-
 src/ext/tinytest_demo.c           |   16 +-
 src/or/circuituse.c               |   10 +-
 src/test/test.c                   |  156 +--
 src/test/test.h                   |    2 +-
 src/test/test_addr.c              |  462 ++++----
 src/test/test_buffers.c           |  336 +++---
 src/test/test_cell_formats.c      |  774 ++++++-------
 src/test/test_cell_queue.c        |   58 +-
 src/test/test_checkdir.c          |   62 +-
 src/test/test_circuitlist.c       |  128 +--
 src/test/test_circuitmux.c        |    8 +-
 src/test/test_config.c            |   50 +-
 src/test/test_containers.c        |  386 +++----
 src/test/test_controller_events.c |   52 +-
 src/test/test_crypto.c            |  536 ++++-----
 src/test/test_dir.c               |  698 ++++++------
 src/test/test_entrynodes.c        |  106 +-
 src/test/test_extorport.c         |  184 ++--
 src/test/test_hs.c                |    8 +-
 src/test/test_introduce.c         |    2 +-
 src/test/test_logging.c           |   30 +-
 src/test/test_microdesc.c         |  162 +--
 src/test/test_nodelist.c          |    4 +-
 src/test/test_oom.c               |   80 +-
 src/test/test_options.c           |    6 +-
 src/test/test_policy.c            |   40 +-
 src/test/test_pt.c                |   70 +-
 src/test/test_relaycell.c         |   54 +-
 src/test/test_replay.c            |   52 +-
 src/test/test_routerkeys.c        |   16 +-
 src/test/test_routerset.c         |  276 ++---
 src/test/test_socks.c             |  302 ++---
 src/test/test_status.c            |  242 ++--
 src/test/test_util.c              | 2190 ++++++++++++++++++-------------------
 35 files changed, 3780 insertions(+), 3780 deletions(-)

diff --git a/src/common/compat_libevent.c b/src/common/compat_libevent.c
index 33672f0..4cfe5cc 100644
--- a/src/common/compat_libevent.c
+++ b/src/common/compat_libevent.c
@@ -717,7 +717,7 @@ tor_gettimeofday_cached_monotonic(struct timeval *tv)
   struct timeval last_tv = { 0, 0 };
 
   tor_gettimeofday_cached(tv);
-  if (timercmp(tv, &last_tv, <)) {
+  if (timercmp(tv, &last_tv, OP_LT)) {
     memcpy(tv, &last_tv, sizeof(struct timeval));
   } else {
     memcpy(&last_tv, tv, sizeof(struct timeval));
diff --git a/src/ext/tinytest_demo.c b/src/ext/tinytest_demo.c
index 634e112..c07f099 100644
--- a/src/ext/tinytest_demo.c
+++ b/src/ext/tinytest_demo.c
@@ -74,13 +74,13 @@ test_strcmp(void *data)
 	   values of the failing things.
 
 	   Fail unless strcmp("abc, "abc") == 0 */
-	tt_int_op(strcmp("abc", "abc"), ==, 0);
+	tt_int_op(strcmp("abc", "abc"), OP_EQ, 0);
 
 	/* Fail unless strcmp("abc, "abcd") is less than 0 */
-	tt_int_op(strcmp("abc", "abcd"), < , 0);
+	tt_int_op(strcmp("abc", "abcd"), OP_LT, 0);
 
 	/* Incidentally, there's a test_str_op that uses strcmp internally. */
-	tt_str_op("abc", <, "abcd");
+	tt_str_op("abc", OP_LT, "abcd");
 
 
 	/* Every test-case function needs to finish with an "end:"
@@ -153,11 +153,11 @@ test_memcpy(void *ptr)
 	/* Let's make sure that memcpy does what we'd like. */
 	strcpy(db->buffer1, "String 0");
 	memcpy(db->buffer2, db->buffer1, sizeof(db->buffer1));
-	tt_str_op(db->buffer1, ==, db->buffer2);
+	tt_str_op(db->buffer1, OP_EQ, db->buffer2);
 
         /* tt_mem_op() does a memcmp, as opposed to the strcmp in tt_str_op() */
         db->buffer2[100] = 3; /* Make the buffers unequal */
-        tt_mem_op(db->buffer1, <, db->buffer2, sizeof(db->buffer1));
+        tt_mem_op(db->buffer1, OP_LT, db->buffer2, sizeof(db->buffer1));
 
 	/* Now we've allocated memory that's referenced by a local variable.
 	   The end block of the function will clean it up. */
@@ -165,7 +165,7 @@ test_memcpy(void *ptr)
 	tt_assert(mem);
 
 	/* Another rather trivial test. */
-	tt_str_op(db->buffer1, !=, mem);
+	tt_str_op(db->buffer1, OP_NE, mem);
 
  end:
 	/* This time our end block has something to do. */
@@ -186,9 +186,9 @@ test_timeout(void *ptr)
 #endif
 	t2 = time(NULL);
 
-	tt_int_op(t2-t1, >=, 4);
+	tt_int_op(t2-t1, OP_GE, 4);
 
-	tt_int_op(t2-t1, <=, 6);
+	tt_int_op(t2-t1, OP_LE, 6);
 
  end:
 	;
diff --git a/src/or/circuituse.c b/src/or/circuituse.c
index 10bc45f..ad4a3a5 100644
--- a/src/or/circuituse.c
+++ b/src/or/circuituse.c
@@ -200,7 +200,7 @@ circuit_is_better(const origin_circuit_t *oa, const origin_circuit_t *ob,
           return 1;
       } else {
         if (a->timestamp_dirty ||
-            timercmp(&a->timestamp_began, &b->timestamp_began, >))
+            timercmp(&a->timestamp_began, &b->timestamp_began, OP_GT))
           return 1;
         if (ob->build_state->is_internal)
           /* XXX023 what the heck is this internal thing doing here. I
@@ -514,7 +514,7 @@ circuit_expire_building(void)
     if (TO_ORIGIN_CIRCUIT(victim)->hs_circ_has_timed_out)
       cutoff = hs_extremely_old_cutoff;
 
-    if (timercmp(&victim->timestamp_began, &cutoff, >))
+    if (timercmp(&victim->timestamp_began, &cutoff, OP_GT))
       continue; /* it's still young, leave it alone */
 
     /* We need to double-check the opened state here because
@@ -524,7 +524,7 @@ circuit_expire_building(void)
      * aren't either. */
     if (!any_opened_circs && victim->state != CIRCUIT_STATE_OPEN) {
       /* It's still young enough that we wouldn't close it, right? */
-      if (timercmp(&victim->timestamp_began, &close_cutoff, >)) {
+      if (timercmp(&victim->timestamp_began, &close_cutoff, OP_GT)) {
         if (!TO_ORIGIN_CIRCUIT(victim)->relaxed_timeout) {
           int first_hop_succeeded = TO_ORIGIN_CIRCUIT(victim)->cpath->state
                                       == CPATH_STATE_OPEN;
@@ -672,7 +672,7 @@ circuit_expire_building(void)
          * it off at, we probably had a suspend event along this codepath,
          * and we should discard the value.
          */
-        if (timercmp(&victim->timestamp_began, &extremely_old_cutoff, <)) {
+        if (timercmp(&victim->timestamp_began, &extremely_old_cutoff, OP_LT)) {
           log_notice(LD_CIRC,
                      "Extremely large value for circuit build timeout: %lds. "
                      "Assuming clock jump. Purpose %d (%s)",
@@ -1255,7 +1255,7 @@ circuit_expire_old_circuits_clientside(void)
       if (circ->purpose != CIRCUIT_PURPOSE_PATH_BIAS_TESTING)
         circuit_mark_for_close(circ, END_CIRC_REASON_FINISHED);
     } else if (!circ->timestamp_dirty && circ->state == CIRCUIT_STATE_OPEN) {
-      if (timercmp(&circ->timestamp_began, &cutoff, <)) {
+      if (timercmp(&circ->timestamp_began, &cutoff, OP_LT)) {
         if (circ->purpose == CIRCUIT_PURPOSE_C_GENERAL ||
                 circ->purpose == CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT ||
                 circ->purpose == CIRCUIT_PURPOSE_S_ESTABLISH_INTRO ||
diff --git a/src/test/test.c b/src/test/test.c
index 8b74c0a..8227176 100644
--- a/src/test/test.c
+++ b/src/test/test.c
@@ -277,9 +277,9 @@ test_onion_handshake(void *arg)
     memset(c_keys, 0, 40);
     tt_assert(! onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40));
 
-    tt_mem_op(c_keys,==, s_keys, 40);
+    tt_mem_op(c_keys,OP_EQ, s_keys, 40);
     memset(s_buf, 0, 40);
-    tt_mem_op(c_keys,!=, s_buf, 40);
+    tt_mem_op(c_keys,OP_NE, s_buf, 40);
   }
  done:
   crypto_dh_free(c_dh);
@@ -311,7 +311,7 @@ test_bad_onion_handshake(void *arg)
   memset(junk_buf, 0, sizeof(junk_buf));
   crypto_pk_public_hybrid_encrypt(pk, junk_buf2, TAP_ONIONSKIN_CHALLENGE_LEN,
                                junk_buf, DH_KEY_LEN, PK_PKCS1_OAEP_PADDING, 1);
-  tt_int_op(-1, ==,
+  tt_int_op(-1, OP_EQ,
             onion_skin_TAP_server_handshake(junk_buf2, pk, NULL,
                                             s_buf, s_keys, 40));
 
@@ -320,7 +320,7 @@ test_bad_onion_handshake(void *arg)
   memset(junk_buf2, 0, sizeof(junk_buf2));
   crypto_pk_public_encrypt(pk, junk_buf2, sizeof(junk_buf2),
                                junk_buf, 48, PK_PKCS1_OAEP_PADDING);
-  tt_int_op(-1, ==,
+  tt_int_op(-1, OP_EQ,
             onion_skin_TAP_server_handshake(junk_buf2, pk, NULL,
                                             s_buf, s_keys, 40));
 
@@ -329,36 +329,36 @@ test_bad_onion_handshake(void *arg)
   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, ==,
+  tt_int_op(-1, OP_EQ,
             onion_skin_TAP_server_handshake(c_buf, pk2, NULL,
                                             s_buf, s_keys, 40));
 
   /* Server: Case 4: The RSA-encrypted portion is corrupt. */
   c_buf[64] ^= 33;
-  tt_int_op(-1, ==,
+  tt_int_op(-1, OP_EQ,
             onion_skin_TAP_server_handshake(c_buf, pk, NULL,
                                             s_buf, s_keys, 40));
   c_buf[64] ^= 33;
 
   /* (Let the server procede) */
-  tt_int_op(0, ==,
+  tt_int_op(0, OP_EQ,
             onion_skin_TAP_server_handshake(c_buf, pk, NULL,
                                             s_buf, s_keys, 40));
 
   /* Client: Case 1: The server sent back junk. */
   s_buf[64] ^= 33;
-  tt_int_op(-1, ==,
+  tt_int_op(-1, OP_EQ,
             onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40));
   s_buf[64] ^= 33;
 
   /* Let the client finish; make sure it can. */
-  tt_int_op(0, ==,
+  tt_int_op(0, OP_EQ,
             onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40));
-  tt_mem_op(s_keys,==, c_keys, 40);
+  tt_mem_op(s_keys,OP_EQ, c_keys, 40);
 
   /* Client: Case 2: The server sent back a degenerate DH. */
   memset(s_buf, 0, sizeof(s_buf));
-  tt_int_op(-1, ==,
+  tt_int_op(-1, OP_EQ,
             onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40));
 
  done:
@@ -395,24 +395,24 @@ test_ntor_handshake(void *arg)
 
   /* client handshake 1. */
   memset(c_buf, 0, NTOR_ONIONSKIN_LEN);
-  tt_int_op(0, ==, onion_skin_ntor_create(node_id, server_pubkey,
+  tt_int_op(0, OP_EQ, onion_skin_ntor_create(node_id, server_pubkey,
                                           &c_state, c_buf));
 
   /* server handshake */
   memset(s_buf, 0, NTOR_REPLY_LEN);
   memset(s_keys, 0, 40);
-  tt_int_op(0, ==, onion_skin_ntor_server_handshake(c_buf, s_keymap, NULL,
+  tt_int_op(0, OP_EQ, onion_skin_ntor_server_handshake(c_buf, s_keymap, NULL,
                                                     node_id,
                                                     s_buf, s_keys, 400));
 
   /* client handshake 2 */
   memset(c_keys, 0, 40);
-  tt_int_op(0, ==, onion_skin_ntor_client_handshake(c_state, s_buf,
+  tt_int_op(0, OP_EQ, onion_skin_ntor_client_handshake(c_state, s_buf,
                                                     c_keys, 400));
 
-  tt_mem_op(c_keys,==, s_keys, 400);
+  tt_mem_op(c_keys,OP_EQ, s_keys, 400);
   memset(s_buf, 0, 40);
-  tt_mem_op(c_keys,!=, s_buf, 40);
+  tt_mem_op(c_keys,OP_NE, s_buf, 40);
 
  done:
   ntor_handshake_state_free(c_state);
@@ -440,24 +440,24 @@ test_onion_queues(void *arg)
   create_cell_init(create2, CELL_CREATE, ONION_HANDSHAKE_TYPE_NTOR,
                    NTOR_ONIONSKIN_LEN, buf2);
 
-  tt_int_op(0,==, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
-  tt_int_op(0,==, onion_pending_add(circ1, create1));
+  tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
+  tt_int_op(0,OP_EQ, onion_pending_add(circ1, create1));
   create1 = NULL;
-  tt_int_op(1,==, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
+  tt_int_op(1,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
 
-  tt_int_op(0,==, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
-  tt_int_op(0,==, onion_pending_add(circ2, create2));
+  tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
+  tt_int_op(0,OP_EQ, onion_pending_add(circ2, create2));
   create2 = NULL;
-  tt_int_op(1,==, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
+  tt_int_op(1,OP_EQ, 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);
+  tt_ptr_op(circ2,OP_EQ, onion_next_task(&onionskin));
+  tt_int_op(1,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
+  tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
+  tt_ptr_op(onionskin, OP_EQ, create2_ptr);
 
   clear_pending_onions();
-  tt_int_op(0,==, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
-  tt_int_op(0,==, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
+  tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
+  tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
 
  done:
   circuit_free(TO_CIRCUIT(circ1));
@@ -648,13 +648,13 @@ test_rend_fns(void *arg)
   (void)arg;
   tt_assert(BAD_HOSTNAME == parse_extended_hostname(address1));
   tt_assert(ONION_HOSTNAME == parse_extended_hostname(address2));
-  tt_str_op(address2,==, "aaaaaaaaaaaaaaaa");
+  tt_str_op(address2,OP_EQ, "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_str_op(address5,OP_EQ, "abcdefghijklmnop");
   tt_assert(ONION_HOSTNAME == parse_extended_hostname(address6));
-  tt_str_op(address6,==, "abcdefghijklmnop");
+  tt_str_op(address6,OP_EQ, "abcdefghijklmnop");
   tt_assert(BAD_HOSTNAME == parse_extended_hostname(address7));
 
   pk1 = pk_generate(0);
@@ -693,7 +693,7 @@ test_rend_fns(void *arg)
   tt_assert(rend_compute_v2_desc_id(computed_desc_id, service_id_base32,
                                       NULL, now, 0) == 0);
   tt_mem_op(((rend_encoded_v2_service_descriptor_t *)
-             smartlist_get(descs, 0))->desc_id, ==,
+             smartlist_get(descs, 0))->desc_id, OP_EQ,
             computed_desc_id, DIGEST_LEN);
   tt_assert(rend_parse_v2_service_descriptor(&parsed, parsed_desc_id,
                                                &intro_points_encrypted,
@@ -704,25 +704,25 @@ test_rend_fns(void *arg)
                                      smartlist_get(descs, 0))->desc_str) == 0);
   tt_assert(parsed);
   tt_mem_op(((rend_encoded_v2_service_descriptor_t *)
-             smartlist_get(descs, 0))->desc_id,==, parsed_desc_id, DIGEST_LEN);
+             smartlist_get(descs, 0))->desc_id,OP_EQ, parsed_desc_id, DIGEST_LEN);
   tt_int_op(rend_parse_introduction_points(parsed, intro_points_encrypted,
-                                         intro_points_size),==, 3);
+                                         intro_points_size),OP_EQ, 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);
+  tt_int_op(parsed->timestamp,OP_EQ, now);
+  tt_int_op(parsed->version,OP_EQ, 2);
+  tt_int_op(parsed->protocols,OP_EQ, 42);
+  tt_int_op(smartlist_len(parsed->intro_nodes),OP_EQ, 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;
     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,
+    tt_mem_op(gen_info->identity_digest,OP_EQ, par_info->identity_digest,
                DIGEST_LEN);
-    tt_str_op(gen_info->nickname,==, par_info->nickname);
+    tt_str_op(gen_info->nickname,OP_EQ, par_info->nickname);
     tt_assert(tor_addr_eq(&gen_info->addr, &par_info->addr));
-    tt_int_op(gen_info->port,==, par_info->port);
+    tt_int_op(gen_info->port,OP_EQ, par_info->port);
   }
 
   rend_service_descriptor_free(parsed);
@@ -766,11 +766,11 @@ test_rend_fns(void *arg)
   } while (0)
 #define CHECK_COUNTRY(country, val) do {                                \
     /* test ipv4 country lookup */                                      \
-    tt_str_op(country, ==,                                              \
+    tt_str_op(country, OP_EQ,                                              \
                geoip_get_country_name(geoip_get_country_by_ipv4(val))); \
     /* test ipv6 country lookup */                                      \
     SET_TEST_IPV6(val);                                                 \
-    tt_str_op(country, ==,                                              \
+    tt_str_op(country, OP_EQ,                                              \
                geoip_get_country_name(geoip_get_country_by_ipv6(&in6))); \
   } while (0)
 
@@ -831,23 +831,23 @@ test_geoip(void *arg)
    * 'sort' step.  These aren't very good IP addresses, but they're perfectly
    * fine uint32_t values. */
   (void)arg;
-  tt_int_op(0,==, geoip_parse_entry("10,50,AB", AF_INET));
-  tt_int_op(0,==, geoip_parse_entry("52,90,XY", AF_INET));
-  tt_int_op(0,==, geoip_parse_entry("95,100,AB", AF_INET));
-  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));
+  tt_int_op(0,OP_EQ, geoip_parse_entry("10,50,AB", AF_INET));
+  tt_int_op(0,OP_EQ, geoip_parse_entry("52,90,XY", AF_INET));
+  tt_int_op(0,OP_EQ, geoip_parse_entry("95,100,AB", AF_INET));
+  tt_int_op(0,OP_EQ, geoip_parse_entry("\"105\",\"140\",\"ZZ\"", AF_INET));
+  tt_int_op(0,OP_EQ, geoip_parse_entry("\"150\",\"190\",\"XY\"", AF_INET));
+  tt_int_op(0,OP_EQ, geoip_parse_entry("\"200\",\"250\",\"AB\"", AF_INET));
 
   /* Populate the IPv6 DB equivalently with fake IPs in the same range */
-  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));
+  tt_int_op(0,OP_EQ, geoip_parse_entry("::a,::32,AB", AF_INET6));
+  tt_int_op(0,OP_EQ, geoip_parse_entry("::34,::5a,XY", AF_INET6));
+  tt_int_op(0,OP_EQ, geoip_parse_entry("::5f,::64,AB", AF_INET6));
+  tt_int_op(0,OP_EQ, geoip_parse_entry("::69,::8c,ZZ", AF_INET6));
+  tt_int_op(0,OP_EQ, geoip_parse_entry("::96,::be,XY", AF_INET6));
+  tt_int_op(0,OP_EQ, geoip_parse_entry("::c8,::fa,AB", AF_INET6));
 
   /* We should have 4 countries: ??, ab, xy, zz. */
-  tt_int_op(4,==, geoip_get_n_countries());
+  tt_int_op(4,OP_EQ, geoip_get_n_countries());
   memset(&in6, 0, sizeof(in6));
 
   CHECK_COUNTRY("??", 3);
@@ -858,9 +858,9 @@ test_geoip(void *arg)
   CHECK_COUNTRY("xy", 190);
   CHECK_COUNTRY("??", 2000);
 
-  tt_int_op(0,==, geoip_get_country_by_ipv4(3));
+  tt_int_op(0,OP_EQ, geoip_get_country_by_ipv4(3));
   SET_TEST_IPV6(3);
-  tt_int_op(0,==, geoip_get_country_by_ipv6(&in6));
+  tt_int_op(0,OP_EQ, geoip_get_country_by_ipv6(&in6));
 
   get_options_mutable()->BridgeRelay = 1;
   get_options_mutable()->BridgeRecordUsageByCountry = 1;
@@ -885,8 +885,8 @@ test_geoip(void *arg)
   geoip_get_client_history(GEOIP_CLIENT_CONNECT, &s, &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);
+  tt_str_op("zz=24,ab=16,xy=8",OP_EQ, s);
+  tt_str_op("v4=16,v6=16",OP_EQ, v);
   tor_free(s);
   tor_free(v);
 
@@ -895,8 +895,8 @@ test_geoip(void *arg)
   geoip_get_client_history(GEOIP_CLIENT_CONNECT, &s, &v);
   tt_assert(s);
   tt_assert(v);
-  tt_str_op("zz=24,xy=8",==, s);
-  tt_str_op("v4=16,v6=16",==, v);
+  tt_str_op("zz=24,xy=8",OP_EQ, s);
+  tt_str_op("v4=16,v6=16",OP_EQ, v);
   tor_free(s);
   tor_free(v);
 
@@ -910,7 +910,7 @@ test_geoip(void *arg)
   geoip_bridge_stats_init(now);
   s = geoip_format_bridge_stats(now + 86400);
   tt_assert(s);
-  tt_str_op(bridge_stats_1,==, s);
+  tt_str_op(bridge_stats_1,OP_EQ, s);
   tor_free(s);
 
   /* Stop collecting bridge stats and make sure we don't write a history
@@ -939,7 +939,7 @@ test_geoip(void *arg)
   SET_TEST_ADDRESS(100);
   geoip_note_client_seen(GEOIP_CLIENT_NETWORKSTATUS, &addr, NULL, now);
   s = geoip_format_dirreq_stats(now + 86400);
-  tt_str_op(dirreq_stats_1,==, s);
+  tt_str_op(dirreq_stats_1,OP_EQ, s);
   tor_free(s);
 
   /* Stop collecting stats, add another connecting client, and ensure we
@@ -957,20 +957,20 @@ test_geoip(void *arg)
   geoip_note_client_seen(GEOIP_CLIENT_NETWORKSTATUS, &addr, NULL, now);
   geoip_reset_dirreq_stats(now);
   s = geoip_format_dirreq_stats(now + 86400);
-  tt_str_op(dirreq_stats_2,==, s);
+  tt_str_op(dirreq_stats_2,OP_EQ, 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);
-  tt_str_op(dirreq_stats_3,==, s);
+  tt_str_op(dirreq_stats_3,OP_EQ, 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);
-  tt_str_op(dirreq_stats_4,==, s);
+  tt_str_op(dirreq_stats_4,OP_EQ, s);
   tor_free(s);
 
   /* Stop collecting directory request statistics and start gathering
@@ -992,7 +992,7 @@ test_geoip(void *arg)
   SET_TEST_ADDRESS(100);
   geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
   s = geoip_format_entry_stats(now + 86400);
-  tt_str_op(entry_stats_1,==, s);
+  tt_str_op(entry_stats_1,OP_EQ, s);
   tor_free(s);
 
   /* Stop collecting stats, add another connecting client, and ensure we
@@ -1010,7 +1010,7 @@ test_geoip(void *arg)
   geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
   geoip_reset_entry_stats(now);
   s = geoip_format_entry_stats(now + 86400);
-  tt_str_op(entry_stats_2,==, s);
+  tt_str_op(entry_stats_2,OP_EQ, s);
   tor_free(s);
 
   /* Stop collecting entry statistics. */
@@ -1083,7 +1083,7 @@ test_geoip_with_pt(void *arg)
   /* Test the transport history string. */
   s = geoip_get_transport_history();
   tor_assert(s);
-  tt_str_op(s,==, "<OR>=8,alpha=16,beta=8,charlie=16,ddr=136,"
+  tt_str_op(s,OP_EQ, "<OR>=8,alpha=16,beta=8,charlie=16,ddr=136,"
              "entropy=8,fire=8,google=8");
 
   /* Stop collecting entry statistics. */
@@ -1126,7 +1126,7 @@ test_stats(void *arg)
   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",OP_EQ, s);
   tor_free(s);
 
   /* Add a few bytes on 10 more ports and ensure that only the top 10
@@ -1142,7 +1142,7 @@ test_stats(void *arg)
              "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",OP_EQ, s);
   tor_free(s);
 
   /* Stop collecting stats, add some bytes, and ensure we don't generate
@@ -1162,7 +1162,7 @@ test_stats(void *arg)
   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",OP_EQ, s);
   tor_free(s);
 
   /* Continue with testing connection statistics; we shouldn't collect
@@ -1178,7 +1178,7 @@ test_stats(void *arg)
   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);
-  tt_str_op("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",OP_EQ, s);
   tor_free(s);
 
   /* Stop collecting stats, add some bytes, and ensure we don't generate
@@ -1197,7 +1197,7 @@ test_stats(void *arg)
   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);
-  tt_str_op("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",OP_EQ, s);
   tor_free(s);
 
   /* Continue with testing buffer statistics; we shouldn't collect buffer
@@ -1216,7 +1216,7 @@ test_stats(void *arg)
              "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",OP_EQ, s);
   tor_free(s);
 
   /* Add nineteen more circuit statistics to the one that's already in the
@@ -1231,7 +1231,7 @@ test_stats(void *arg)
              "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",OP_EQ, s);
   tor_free(s);
 
   /* Stop collecting stats, add statistics for one circuit, and ensure we
@@ -1252,7 +1252,7 @@ test_stats(void *arg)
              "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",OP_EQ, s);
 
  done:
   tor_free(s);
diff --git a/src/test/test.h b/src/test/test.h
index db07e4b..5518ca3 100644
--- a/src/test/test.h
+++ b/src/test/test.h
@@ -34,7 +34,7 @@
   tt_mem_op(expr1, op, mem_op_hex_tmp, length/2);                       \
   STMT_END
 
-#define test_memeq_hex(expr1, hex) test_mem_op_hex(expr1, ==, hex)
+#define test_memeq_hex(expr1, hex) test_mem_op_hex(expr1, OP_EQ, hex)
 
 #define tt_double_op(a,op,b)                                            \
   tt_assert_test_type(a,b,#a" "#op" "#b,double,(val1_ op val2_),"%f",   \
diff --git a/src/test/test_addr.c b/src/test/test_addr.c
index e9fe303..b7fe2c4 100644
--- a/src/test/test_addr.c
+++ b/src/test/test_addr.c
@@ -20,40 +20,40 @@ test_addr_basic(void *arg)
   (void)arg;
   cp = NULL; u32 = 3; u16 = 3;
   tt_assert(!addr_port_lookup(LOG_WARN, "1.2.3.4", &cp, &u32, &u16));
-  tt_str_op(cp,==, "1.2.3.4");
-  tt_int_op(u32,==, 0x01020304u);
-  tt_int_op(u16,==, 0);
+  tt_str_op(cp,OP_EQ, "1.2.3.4");
+  tt_int_op(u32,OP_EQ, 0x01020304u);
+  tt_int_op(u16,OP_EQ, 0);
   tor_free(cp);
   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);
+  tt_str_op(cp,OP_EQ, "4.3.2.1");
+  tt_int_op(u32,OP_EQ, 0x04030201u);
+  tt_int_op(u16,OP_EQ, 99);
   tor_free(cp);
   tt_assert(!addr_port_lookup(LOG_WARN, "nonexistent.address:4040",
                                &cp, NULL, &u16));
-  tt_str_op(cp,==, "nonexistent.address");
-  tt_int_op(u16,==, 4040);
+  tt_str_op(cp,OP_EQ, "nonexistent.address");
+  tt_int_op(u16,OP_EQ, 4040);
   tor_free(cp);
   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);
+  tt_str_op(cp,OP_EQ, "localhost");
+  tt_int_op(u32,OP_EQ, 0x7f000001u);
+  tt_int_op(u16,OP_EQ, 9999);
   tor_free(cp);
   u32 = 3;
   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);
+  tt_ptr_op(cp,OP_EQ, NULL);
+  tt_int_op(u32,OP_EQ, 0x7f000001u);
+  tt_int_op(u16,OP_EQ, 0);
   tor_free(cp);
 
   tt_assert(addr_port_lookup(LOG_WARN, "localhost:3", &cp, &u32, NULL));
   tor_free(cp);
 
-  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));
+  tt_int_op(0,OP_EQ, addr_mask_get_bits(0x0u));
+  tt_int_op(32,OP_EQ, addr_mask_get_bits(0xFFFFFFFFu));
+  tt_int_op(16,OP_EQ, addr_mask_get_bits(0xFFFF0000u));
+  tt_int_op(31,OP_EQ, addr_mask_get_bits(0xFFFFFFFEu));
+  tt_int_op(1,OP_EQ, addr_mask_get_bits(0x80000000u));
 
   /* Test inet_ntop */
   {
@@ -62,15 +62,15 @@ test_addr_basic(void *arg)
     struct in_addr in;
 
     /* good round trip */
-    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);
+    tt_int_op(tor_inet_pton(AF_INET, ip, &in),OP_EQ, 1);
+    tt_ptr_op(tor_inet_ntop(AF_INET, &in, tmpbuf, sizeof(tmpbuf)),OP_EQ, &tmpbuf);
+    tt_str_op(tmpbuf,OP_EQ, ip);
 
     /* just enough buffer length */
-    tt_str_op(tor_inet_ntop(AF_INET, &in, tmpbuf, strlen(ip) + 1),==, ip);
+    tt_str_op(tor_inet_ntop(AF_INET, &in, tmpbuf, strlen(ip) + 1),OP_EQ, ip);
 
     /* too short buffer */
-    tt_ptr_op(tor_inet_ntop(AF_INET, &in, tmpbuf, strlen(ip)),==, NULL);
+    tt_ptr_op(tor_inet_ntop(AF_INET, &in, tmpbuf, strlen(ip)),OP_EQ, NULL);
   }
 
  done:
@@ -98,30 +98,30 @@ test_addr_basic(void *arg)
 /** Helper: Assert that two strings both decode as IPv6 addresses with
  * tor_inet_pton(), and both decode to the same address. */
 #define test_pton6_same(a,b) STMT_BEGIN                 \
-     tt_int_op(tor_inet_pton(AF_INET6, a, &a1), ==, 1); \
-     tt_int_op(tor_inet_pton(AF_INET6, b, &a2), ==, 1); \
-     test_op_ip6_(&a1,==,&a2,#a,#b);                    \
+     tt_int_op(tor_inet_pton(AF_INET6, a, &a1), OP_EQ, 1); \
+     tt_int_op(tor_inet_pton(AF_INET6, b, &a2), OP_EQ, 1); \
+     test_op_ip6_(&a1,OP_EQ,&a2,#a,#b);                    \
   STMT_END
 
 /** Helper: Assert that <b>a</b> is recognized as a bad IPv6 address by
  * tor_inet_pton(). */
 #define test_pton6_bad(a)                       \
-  tt_int_op(0, ==, tor_inet_pton(AF_INET6, a, &a1))
+  tt_int_op(0, OP_EQ, tor_inet_pton(AF_INET6, a, &a1))
 
 /** Helper: assert that <b>a</b>, when parsed by tor_inet_pton() and displayed
  * with tor_inet_ntop(), yields <b>b</b>. Also assert that <b>b</b> parses to
  * the same value as <b>a</b>. */
 #define test_ntop6_reduces(a,b) STMT_BEGIN                          \
-  tt_int_op(tor_inet_pton(AF_INET6, a, &a1), ==, 1);                \
-  tt_str_op(tor_inet_ntop(AF_INET6, &a1, buf, sizeof(buf)), ==, b); \
-  tt_int_op(tor_inet_pton(AF_INET6, b, &a2), ==, 1);     \
-  test_op_ip6_(&a1, ==, &a2, a, b);                      \
+  tt_int_op(tor_inet_pton(AF_INET6, a, &a1), OP_EQ, 1);                \
+  tt_str_op(tor_inet_ntop(AF_INET6, &a1, buf, sizeof(buf)), OP_EQ, b); \
+  tt_int_op(tor_inet_pton(AF_INET6, b, &a2), OP_EQ, 1);     \
+  test_op_ip6_(&a1, OP_EQ, &a2, a, b);                      \
   STMT_END
 
 /** Helper: assert that <b>a</b> parses by tor_inet_pton() into a address that
  * passes tor_addr_is_internal() with <b>for_listening</b>. */
 #define test_internal_ip(a,for_listening) STMT_BEGIN           \
-    tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), ==, 1); \
+    tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), OP_EQ, 1); \
     t1.family = AF_INET6;                                      \
     if (!tor_addr_is_internal(&t1, for_listening))             \
       TT_DIE(("%s was not internal", a));                      \
@@ -130,7 +130,7 @@ test_addr_basic(void *arg)
 /** Helper: assert that <b>a</b> parses by tor_inet_pton() into a address that
  * does not pass tor_addr_is_internal() with <b>for_listening</b>. */
 #define test_external_ip(a,for_listening) STMT_BEGIN           \
-    tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), ==, 1); \
+    tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), OP_EQ, 1); \
     t1.family = AF_INET6;                                      \
     if (tor_addr_is_internal(&t1, for_listening))              \
       TT_DIE(("%s was not internal", a));                      \
@@ -140,8 +140,8 @@ test_addr_basic(void *arg)
  * tor_inet_pton(), give addresses that compare in the order defined by
  * <b>op</b> with tor_addr_compare(). */
 #define test_addr_compare(a, op, b) STMT_BEGIN                    \
-    tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), ==, 1); \
-    tt_int_op(tor_inet_pton(AF_INET6, b, &t2.addr.in6_addr), ==, 1); \
+    tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), OP_EQ, 1); \
+    tt_int_op(tor_inet_pton(AF_INET6, b, &t2.addr.in6_addr), OP_EQ, 1); \
     t1.family = t2.family = AF_INET6;                             \
     r = tor_addr_compare(&t1,&t2,CMP_SEMANTIC);                   \
     if (!(r op 0))                                                \
@@ -152,8 +152,8 @@ test_addr_basic(void *arg)
  * tor_inet_pton(), give addresses that compare in the order defined by
  * <b>op</b> with tor_addr_compare_masked() with <b>m</b> masked. */
 #define test_addr_compare_masked(a, op, b, m) STMT_BEGIN          \
-    tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), ==, 1);    \
-    tt_int_op(tor_inet_pton(AF_INET6, b, &t2.addr.in6_addr), ==, 1);    \
+    tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), OP_EQ, 1);    \
+    tt_int_op(tor_inet_pton(AF_INET6, b, &t2.addr.in6_addr), OP_EQ, 1);    \
     t1.family = t2.family = AF_INET6;                             \
     r = tor_addr_compare_masked(&t1,&t2,m,CMP_SEMANTIC);          \
     if (!(r op 0))                                                \
@@ -168,15 +168,15 @@ test_addr_basic(void *arg)
 #define test_addr_mask_ports_parse(xx, f, ip1, ip2, ip3, ip4, mm, pt1, pt2) \
   STMT_BEGIN                                                                \
     tt_int_op(tor_addr_parse_mask_ports(xx, 0, &t1, &mask, &port1, &port2),   \
-              ==, f);                                                   \
+              OP_EQ, f);                                                   \
     p1=tor_inet_ntop(AF_INET6, &t1.addr.in6_addr, bug, sizeof(bug));        \
-    tt_int_op(htonl(ip1), ==, tor_addr_to_in6_addr32(&t1)[0]);            \
-    tt_int_op(htonl(ip2), ==, tor_addr_to_in6_addr32(&t1)[1]);            \
-    tt_int_op(htonl(ip3), ==, tor_addr_to_in6_addr32(&t1)[2]);            \
-    tt_int_op(htonl(ip4), ==, tor_addr_to_in6_addr32(&t1)[3]);            \
-    tt_int_op(mask, ==, mm);                     \
-    tt_uint_op(port1, ==, pt1);                  \
-    tt_uint_op(port2, ==, pt2);                  \
+    tt_int_op(htonl(ip1), OP_EQ, tor_addr_to_in6_addr32(&t1)[0]);            \
+    tt_int_op(htonl(ip2), OP_EQ, tor_addr_to_in6_addr32(&t1)[1]);            \
+    tt_int_op(htonl(ip3), OP_EQ, tor_addr_to_in6_addr32(&t1)[2]);            \
+    tt_int_op(htonl(ip4), OP_EQ, tor_addr_to_in6_addr32(&t1)[3]);            \
+    tt_int_op(mask, OP_EQ, mm);                     \
+    tt_uint_op(port1, OP_EQ, pt1);                  \
+    tt_uint_op(port2, OP_EQ, pt2);                  \
   STMT_END
 
 /** Run unit tests for IPv6 encoding/decoding/manipulation functions. */
@@ -202,23 +202,23 @@ test_addr_ip6_helpers(void *arg)
     const char *ip_ffff = "::ffff:192.168.1.2";
 
     /* good round trip */
-    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);
+    tt_int_op(tor_inet_pton(AF_INET6, ip, &a1),OP_EQ, 1);
+    tt_ptr_op(tor_inet_ntop(AF_INET6, &a1, buf, sizeof(buf)),OP_EQ, &buf);
+    tt_str_op(buf,OP_EQ, ip);
 
     /* good round trip - ::ffff:0:0 style */
-    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);
+    tt_int_op(tor_inet_pton(AF_INET6, ip_ffff, &a2),OP_EQ, 1);
+    tt_ptr_op(tor_inet_ntop(AF_INET6, &a2, buf, sizeof(buf)),OP_EQ, &buf);
+    tt_str_op(buf,OP_EQ, ip_ffff);
 
     /* just long enough buffer (remember \0) */
-    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),==,
+    tt_str_op(tor_inet_ntop(AF_INET6, &a1, buf, strlen(ip)+1),OP_EQ, ip);
+    tt_str_op(tor_inet_ntop(AF_INET6, &a2, buf, strlen(ip_ffff)+1),OP_EQ,
                ip_ffff);
 
     /* too short buffer (remember \0) */
-    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);
+    tt_ptr_op(tor_inet_ntop(AF_INET6, &a1, buf, strlen(ip)),OP_EQ, NULL);
+    tt_ptr_op(tor_inet_ntop(AF_INET6, &a2, buf, strlen(ip_ffff)),OP_EQ, NULL);
   }
 
   /* ==== Converting to and from sockaddr_t. */
@@ -227,16 +227,16 @@ test_addr_ip6_helpers(void *arg)
   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);
-  tt_int_op(tor_addr_family(&t1),==, AF_INET);
-  tt_int_op(tor_addr_to_ipv4h(&t1),==, 0x7f7f0102);
-  tt_int_op(port1, ==, 9090);
+  tt_int_op(tor_addr_family(&t1),OP_EQ, AF_INET);
+  tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ, 0x7f7f0102);
+  tt_int_op(port1, OP_EQ, 9090);
 
   memset(&sa_storage, 0, sizeof(sa_storage));
-  tt_int_op(sizeof(struct sockaddr_in),==,
+  tt_int_op(sizeof(struct sockaddr_in),OP_EQ,
           tor_addr_to_sockaddr(&t1, 1234, (struct sockaddr *)&sa_storage,
                                sizeof(sa_storage)));
-  tt_int_op(1234,==, ntohs(sin->sin_port));
-  tt_int_op(0x7f7f0102,==, ntohl(sin->sin_addr.s_addr));
+  tt_int_op(1234,OP_EQ, ntohs(sin->sin_port));
+  tt_int_op(0x7f7f0102,OP_EQ, ntohl(sin->sin_addr.s_addr));
 
   memset(&sa_storage, 0, sizeof(sa_storage));
   sin6 = (struct sockaddr_in6 *)&sa_storage;
@@ -244,37 +244,37 @@ test_addr_ip6_helpers(void *arg)
   sin6->sin6_port = htons(7070);
   sin6->sin6_addr.s6_addr[0] = 128;
   tor_addr_from_sockaddr(&t1, (struct sockaddr *)sin6, &port1);
-  tt_int_op(tor_addr_family(&t1),==, AF_INET6);
-  tt_int_op(port1, ==, 7070);
+  tt_int_op(tor_addr_family(&t1),OP_EQ, AF_INET6);
+  tt_int_op(port1, OP_EQ, 7070);
   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 0);
-  tt_str_op(p1,==, "8000::");
+  tt_str_op(p1,OP_EQ, "8000::");
 
   memset(&sa_storage, 0, sizeof(sa_storage));
-  tt_int_op(sizeof(struct sockaddr_in6),==,
+  tt_int_op(sizeof(struct sockaddr_in6),OP_EQ,
           tor_addr_to_sockaddr(&t1, 9999, (struct sockaddr *)&sa_storage,
                                sizeof(sa_storage)));
-  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]));
+  tt_int_op(AF_INET6,OP_EQ, sin6->sin6_family);
+  tt_int_op(9999,OP_EQ, ntohs(sin6->sin6_port));
+  tt_int_op(0x80000000,OP_EQ, ntohl(S6_ADDR32(sin6->sin6_addr)[0]));
 
   /* ==== tor_addr_lookup: static cases.  (Can't test dns without knowing we
    * have a good resolver. */
-  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);
+  tt_int_op(0,OP_EQ, tor_addr_lookup("127.128.129.130", AF_UNSPEC, &t1));
+  tt_int_op(AF_INET,OP_EQ, tor_addr_family(&t1));
+  tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ, 0x7f808182);
 
-  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_int_op(0,OP_EQ, tor_addr_lookup("9000::5", AF_UNSPEC, &t1));
+  tt_int_op(AF_INET6,OP_EQ, tor_addr_family(&t1));
+  tt_int_op(0x90,OP_EQ, 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]);
+  tt_int_op(0x05,OP_EQ, 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);
-  tt_int_op(r, ==, 1);
-  for (i=0;i<16;++i) { tt_int_op(i+1,==, (int)a1.s6_addr[i]); }
+  tt_int_op(r, OP_EQ, 1);
+  for (i=0;i<16;++i) { tt_int_op(i+1,OP_EQ, (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");
@@ -314,7 +314,7 @@ test_addr_ip6_helpers(void *arg)
                      "1000:1:0:7::");
 
   /* Bad af param */
-  tt_int_op(tor_inet_pton(AF_UNSPEC, 0, 0),==, -1);
+  tt_int_op(tor_inet_pton(AF_UNSPEC, 0, 0),OP_EQ, -1);
 
   /* === Test pton: invalid in6. */
   test_pton6_bad("foobar.");
@@ -410,11 +410,11 @@ test_addr_ip6_helpers(void *arg)
   test_external_ip("::ffff:169.255.0.0", 0);
 
   /* tor_addr_compare(tor_addr_t x2) */
-  test_addr_compare("ffff::", ==, "ffff::0");
-  test_addr_compare("0::3:2:1", <, "0::ffff:0.3.2.1");
-  test_addr_compare("0::2:2:1", <, "0::ffff:0.3.2.1");
-  test_addr_compare("0::ffff:0.3.2.1", >, "0::0:0:0");
-  test_addr_compare("0::ffff:5.2.2.1", <, "::ffff:6.0.0.0"); /* XXXX wrong. */
+  test_addr_compare("ffff::", OP_EQ, "ffff::0");
+  test_addr_compare("0::3:2:1", OP_LT, "0::ffff:0.3.2.1");
+  test_addr_compare("0::2:2:1", OP_LT, "0::ffff:0.3.2.1");
+  test_addr_compare("0::ffff:0.3.2.1", OP_GT, "0::0:0:0");
+  test_addr_compare("0::ffff:5.2.2.1", OP_LT, "::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);
   tt_assert(tor_addr_compare(&t1, &t2, CMP_SEMANTIC) == 0);
@@ -423,119 +423,119 @@ test_addr_ip6_helpers(void *arg)
   tt_assert(tor_addr_compare(&t1, &t2, CMP_SEMANTIC) < 0);
 
   /* test compare_masked */
-  test_addr_compare_masked("ffff::", ==, "ffff::0", 128);
-  test_addr_compare_masked("ffff::", ==, "ffff::0", 64);
-  test_addr_compare_masked("0::2:2:1", <, "0::8000:2:1", 81);
-  test_addr_compare_masked("0::2:2:1", ==, "0::8000:2:1", 80);
+  test_addr_compare_masked("ffff::", OP_EQ, "ffff::0", 128);
+  test_addr_compare_masked("ffff::", OP_EQ, "ffff::0", 64);
+  test_addr_compare_masked("0::2:2:1", OP_LT, "0::8000:2:1", 81);
+  test_addr_compare_masked("0::2:2:1", OP_EQ, "0::8000:2:1", 80);
 
   /* Test undecorated tor_addr_to_str */
-  tt_int_op(AF_INET6,==, tor_addr_parse(&t1, "[123:45:6789::5005:11]"));
+  tt_int_op(AF_INET6,OP_EQ, tor_addr_parse(&t1, "[123:45:6789::5005:11]"));
   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 0);
-  tt_str_op(p1,==, "123:45:6789::5005:11");
-  tt_int_op(AF_INET,==, tor_addr_parse(&t1, "18.0.0.1"));
+  tt_str_op(p1,OP_EQ, "123:45:6789::5005:11");
+  tt_int_op(AF_INET,OP_EQ, tor_addr_parse(&t1, "18.0.0.1"));
   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 0);
-  tt_str_op(p1,==, "18.0.0.1");
+  tt_str_op(p1,OP_EQ, "18.0.0.1");
 
   /* Test decorated tor_addr_to_str */
-  tt_int_op(AF_INET6,==, tor_addr_parse(&t1, "[123:45:6789::5005:11]"));
+  tt_int_op(AF_INET6,OP_EQ, tor_addr_parse(&t1, "[123:45:6789::5005:11]"));
   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
-  tt_str_op(p1,==, "[123:45:6789::5005:11]");
-  tt_int_op(AF_INET,==, tor_addr_parse(&t1, "18.0.0.1"));
+  tt_str_op(p1,OP_EQ, "[123:45:6789::5005:11]");
+  tt_int_op(AF_INET,OP_EQ, tor_addr_parse(&t1, "18.0.0.1"));
   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
-  tt_str_op(p1,==, "18.0.0.1");
+  tt_str_op(p1,OP_EQ, "18.0.0.1");
 
   /* Test buffer bounds checking of tor_addr_to_str */
-  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),==, "[::]");
-
-  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]");
-
-  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");
-
-  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");
+  tt_int_op(AF_INET6,OP_EQ, tor_addr_parse(&t1, "::")); /* 2 + \0 */
+  tt_ptr_op(tor_addr_to_str(buf, &t1, 2, 0),OP_EQ, NULL); /* too short buf */
+  tt_str_op(tor_addr_to_str(buf, &t1, 3, 0),OP_EQ, "::");
+  tt_ptr_op(tor_addr_to_str(buf, &t1, 4, 1),OP_EQ, NULL); /* too short buf */
+  tt_str_op(tor_addr_to_str(buf, &t1, 5, 1),OP_EQ, "[::]");
+
+  tt_int_op(AF_INET6,OP_EQ, tor_addr_parse(&t1, "2000::1337")); /* 10 + \0 */
+  tt_ptr_op(tor_addr_to_str(buf, &t1, 10, 0),OP_EQ, NULL); /* too short buf */
+  tt_str_op(tor_addr_to_str(buf, &t1, 11, 0),OP_EQ, "2000::1337");
+  tt_ptr_op(tor_addr_to_str(buf, &t1, 12, 1),OP_EQ, NULL); /* too short buf */
+  tt_str_op(tor_addr_to_str(buf, &t1, 13, 1),OP_EQ, "[2000::1337]");
+
+  tt_int_op(AF_INET,OP_EQ, tor_addr_parse(&t1, "1.2.3.4")); /* 7 + \0 */
+  tt_ptr_op(tor_addr_to_str(buf, &t1, 7, 0),OP_EQ, NULL); /* too short buf */
+  tt_str_op(tor_addr_to_str(buf, &t1, 8, 0),OP_EQ, "1.2.3.4");
+
+  tt_int_op(AF_INET,OP_EQ, tor_addr_parse(&t1, "255.255.255.255")); /* 15 + \0 */
+  tt_ptr_op(tor_addr_to_str(buf, &t1, 15, 0),OP_EQ, NULL); /* too short buf */
+  tt_str_op(tor_addr_to_str(buf, &t1, 16, 0),OP_EQ, "255.255.255.255");
+  tt_ptr_op(tor_addr_to_str(buf, &t1, 15, 1),OP_EQ, NULL); /* too short buf */
+  tt_str_op(tor_addr_to_str(buf, &t1, 16, 1),OP_EQ, "255.255.255.255");
 
   t1.family = AF_UNSPEC;
-  tt_ptr_op(tor_addr_to_str(buf, &t1, sizeof(buf), 0),==, NULL);
+  tt_ptr_op(tor_addr_to_str(buf, &t1, sizeof(buf), 0),OP_EQ, NULL);
 
   /* Test tor_addr_parse_PTR_name */
   i = tor_addr_parse_PTR_name(&t1, "Foobar.baz", AF_UNSPEC, 0);
-  tt_int_op(0,==, i);
+  tt_int_op(0,OP_EQ, i);
   i = tor_addr_parse_PTR_name(&t1, "Foobar.baz", AF_UNSPEC, 1);
-  tt_int_op(0,==, i);
+  tt_int_op(0,OP_EQ, i);
   i = tor_addr_parse_PTR_name(&t1, "9999999999999999999999999999.in-addr.arpa",
                               AF_UNSPEC, 1);
-  tt_int_op(-1,==, i);
+  tt_int_op(-1,OP_EQ, i);
   i = tor_addr_parse_PTR_name(&t1, "1.0.168.192.in-addr.arpa",
                                          AF_UNSPEC, 1);
-  tt_int_op(1,==, i);
-  tt_int_op(tor_addr_family(&t1),==, AF_INET);
+  tt_int_op(1,OP_EQ, i);
+  tt_int_op(tor_addr_family(&t1),OP_EQ, AF_INET);
   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
-  tt_str_op(p1,==, "192.168.0.1");
+  tt_str_op(p1,OP_EQ, "192.168.0.1");
   i = tor_addr_parse_PTR_name(&t1, "192.168.0.99", AF_UNSPEC, 0);
-  tt_int_op(0,==, i);
+  tt_int_op(0,OP_EQ, i);
   i = tor_addr_parse_PTR_name(&t1, "192.168.0.99", AF_UNSPEC, 1);
-  tt_int_op(1,==, i);
+  tt_int_op(1,OP_EQ, i);
   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
-  tt_str_op(p1,==, "192.168.0.99");
+  tt_str_op(p1,OP_EQ, "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);
-  tt_int_op(1,==, i);
+  tt_int_op(1,OP_EQ, i);
   p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1);
-  tt_str_op(p1,==, "[9dee:effe:ebe1:beef:fedc:ba98:7654:3210]");
+  tt_str_op(p1,OP_EQ, "[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);
-  tt_int_op(i,==, -1);
+  tt_int_op(i,OP_EQ, -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);
-  tt_int_op(i,==, -1);
+  tt_int_op(i,OP_EQ, -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);
-  tt_int_op(i,==, -1);
+  tt_int_op(i,OP_EQ, -1);
   i = tor_addr_parse_PTR_name(&t1, "32.1.1.in-addr.arpa",
                                          AF_UNSPEC, 0);
-  tt_int_op(i,==, -1);
+  tt_int_op(i,OP_EQ, -1);
   i = tor_addr_parse_PTR_name(&t1, ".in-addr.arpa",
                                          AF_UNSPEC, 0);
-  tt_int_op(i,==, -1);
+  tt_int_op(i,OP_EQ, -1);
   i = tor_addr_parse_PTR_name(&t1, "1.2.3.4.5.in-addr.arpa",
                                          AF_UNSPEC, 0);
-  tt_int_op(i,==, -1);
+  tt_int_op(i,OP_EQ, -1);
   i = tor_addr_parse_PTR_name(&t1, "1.2.3.4.5.in-addr.arpa",
                                          AF_INET6, 0);
-  tt_int_op(i,==, -1);
+  tt_int_op(i,OP_EQ, -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);
-  tt_int_op(i,==, -1);
+  tt_int_op(i,OP_EQ, -1);
 
   /* === Test tor_addr_to_PTR_name */
 
@@ -547,19 +547,19 @@ test_addr_ip6_helpers(void *arg)
   tor_addr_from_sockaddr(&t1, (struct sockaddr *)sin, NULL);
 
   /* Check IPv4 PTR - too short buffer */
-  tt_int_op(tor_addr_to_PTR_name(rbuf, 1, &t1),==, -1);
+  tt_int_op(tor_addr_to_PTR_name(rbuf, 1, &t1),OP_EQ, -1);
   tt_int_op(tor_addr_to_PTR_name(rbuf,
                                strlen("3.2.1.127.in-addr.arpa") - 1,
-                               &t1),==, -1);
+                               &t1),OP_EQ, -1);
 
   /* Check IPv4 PTR - valid addr */
-  tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),==,
+  tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),OP_EQ,
           strlen("3.2.1.127.in-addr.arpa"));
-  tt_str_op(rbuf,==, "3.2.1.127.in-addr.arpa");
+  tt_str_op(rbuf,OP_EQ, "3.2.1.127.in-addr.arpa");
 
   /* Invalid addr family */
   t1.family = AF_UNSPEC;
-  tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),==, -1);
+  tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),OP_EQ, -1);
 
   /* Stage IPv6 addr */
   memset(&sa_storage, 0, sizeof(sa_storage));
@@ -576,81 +576,81 @@ test_addr_ip6_helpers(void *arg)
       "0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.ip6.arpa";
 
     /* Check IPv6 PTR - too short buffer */
-    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);
+    tt_int_op(tor_addr_to_PTR_name(rbuf, 0, &t1),OP_EQ, -1);
+    tt_int_op(tor_addr_to_PTR_name(rbuf, strlen(addr_PTR) - 1, &t1),OP_EQ, -1);
 
     /* Check IPv6 PTR - valid addr */
-    tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),==,
+    tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),OP_EQ,
             strlen(addr_PTR));
-    tt_str_op(rbuf,==, addr_PTR);
+    tt_str_op(rbuf,OP_EQ, 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);
-  tt_str_op(p1,==, "::f");
+  tt_str_op(p1,OP_EQ, "::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);
-  tt_str_op(p1,==, "::ffff:4.1.1.7");
+  tt_str_op(p1,OP_EQ, "::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);
 
-  tt_str_op(p1,==, "abcd:2::44a:0");
+  tt_str_op(p1,OP_EQ, "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);
   tt_assert(r == AF_INET6);
   r=tor_addr_parse_mask_ports("[ffff:1111:1111:1111:1111:1111:1111:11111]",
                               0, &t1, NULL, NULL, NULL);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
   r=tor_addr_parse_mask_ports("[ffff:1111:1111:1111:1111:1111:1111:1111:1]",
                               0, &t1, NULL, NULL, NULL);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -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);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
   /* Try some failing cases. */
   r=tor_addr_parse_mask_ports("[fefef::]/112", 0, &t1, NULL, NULL, NULL);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
   r=tor_addr_parse_mask_ports("[fefe::/112", 0, &t1, NULL, NULL, NULL);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
   r=tor_addr_parse_mask_ports("[fefe::", 0, &t1, NULL, NULL, NULL);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
   r=tor_addr_parse_mask_ports("[fefe::X]", 0, &t1, NULL, NULL, NULL);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
   r=tor_addr_parse_mask_ports("efef::/112", 0, &t1, NULL, NULL, NULL);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
   r=tor_addr_parse_mask_ports("[f:f:f:f:f:f:f:f::]",0,&t1, NULL, NULL, NULL);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
   r=tor_addr_parse_mask_ports("[::f:f:f:f:f:f:f:f]",0,&t1, NULL, NULL, NULL);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
   r=tor_addr_parse_mask_ports("[f:f:f:f:f:f:f:f:f]",0,&t1, NULL, NULL, NULL);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
   r=tor_addr_parse_mask_ports("[f:f:f:f:f::]/fred",0,&t1,&mask, NULL, NULL);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
   r=tor_addr_parse_mask_ports("[f:f:f:f:f::]/255.255.0.0",
                               0,&t1, NULL, NULL, NULL);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -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);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -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);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
   r=tor_addr_parse_mask_ports("1.1.2.2/33",0,&t1, &mask, NULL, NULL);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
   /* Try extended wildcard addresses with out TAPMP_EXTENDED_STAR*/
   r=tor_addr_parse_mask_ports("*4",0,&t1, &mask, NULL, NULL);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
   r=tor_addr_parse_mask_ports("*6",0,&t1, &mask, NULL, NULL);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
 #if 0
   /* Try a mask with a wildcard. */
   r=tor_addr_parse_mask_ports("*/16",0,&t1, &mask, NULL, NULL);
@@ -665,57 +665,57 @@ test_addr_ip6_helpers(void *arg)
   /* Basic mask tests*/
   r=tor_addr_parse_mask_ports("1.1.2.2/31",0,&t1, &mask, NULL, NULL);
   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);
+  tt_int_op(mask,OP_EQ,31);
+  tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET);
+  tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ,0x01010202);
   r=tor_addr_parse_mask_ports("3.4.16.032:1-2",0,&t1, &mask, &port1, &port2);
   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);
+  tt_int_op(mask,OP_EQ,32);
+  tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET);
+  tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ,0x03041020);
   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);
   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);
+  tt_int_op(mask,OP_EQ,17);
+  tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET);
+  tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ,0x01010203);
   r=tor_addr_parse_mask_ports("[efef::]/112",0,&t1, &mask, &port1, &port2);
   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 */
-  tt_int_op(tor_addr_family(&t1),==,AF_INET);
-  tt_int_op(tor_addr_to_ipv4h(&t1),==,0);
-  tt_int_op(mask,==,0);
-  tt_int_op(port1,==,80);
-  tt_int_op(port2,==,443);
+  tt_int_op(r,OP_EQ,AF_INET); /* Old users of this always get inet */
+  tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET);
+  tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ,0);
+  tt_int_op(mask,OP_EQ,0);
+  tt_int_op(port1,OP_EQ,80);
+  tt_int_op(port2,OP_EQ,443);
   /* Now try wildcards *with* TAPMP_EXTENDED_STAR */
   r=tor_addr_parse_mask_ports("*:8000-9000",TAPMP_EXTENDED_STAR,
                               &t1,&mask,&port1,&port2);
-  tt_int_op(r,==,AF_UNSPEC);
-  tt_int_op(tor_addr_family(&t1),==,AF_UNSPEC);
-  tt_int_op(mask,==,0);
-  tt_int_op(port1,==,8000);
-  tt_int_op(port2,==,9000);
+  tt_int_op(r,OP_EQ,AF_UNSPEC);
+  tt_int_op(tor_addr_family(&t1),OP_EQ,AF_UNSPEC);
+  tt_int_op(mask,OP_EQ,0);
+  tt_int_op(port1,OP_EQ,8000);
+  tt_int_op(port2,OP_EQ,9000);
   r=tor_addr_parse_mask_ports("*4:6667",TAPMP_EXTENDED_STAR,
                               &t1,&mask,&port1,&port2);
-  tt_int_op(r,==,AF_INET);
-  tt_int_op(tor_addr_family(&t1),==,AF_INET);
-  tt_int_op(tor_addr_to_ipv4h(&t1),==,0);
-  tt_int_op(mask,==,0);
-  tt_int_op(port1,==,6667);
-  tt_int_op(port2,==,6667);
+  tt_int_op(r,OP_EQ,AF_INET);
+  tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET);
+  tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ,0);
+  tt_int_op(mask,OP_EQ,0);
+  tt_int_op(port1,OP_EQ,6667);
+  tt_int_op(port2,OP_EQ,6667);
   r=tor_addr_parse_mask_ports("*6",TAPMP_EXTENDED_STAR,
                               &t1,&mask,&port1,&port2);
-  tt_int_op(r,==,AF_INET6);
-  tt_int_op(tor_addr_family(&t1),==,AF_INET6);
+  tt_int_op(r,OP_EQ,AF_INET6);
+  tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET6);
   tt_assert(tor_mem_is_zero((const char*)tor_addr_to_in6_addr32(&t1), 16));
-  tt_int_op(mask,==,0);
-  tt_int_op(port1,==,1);
-  tt_int_op(port2,==,65535);
+  tt_int_op(mask,OP_EQ,0);
+  tt_int_op(port1,OP_EQ,1);
+  tt_int_op(port2,OP_EQ,65535);
 
   /* make sure inet address lengths >= max */
   tt_assert(INET_NTOA_BUF_LEN >= sizeof("255.255.255.255"));
@@ -751,87 +751,87 @@ test_addr_parse(void *arg)
   r= tor_addr_port_parse(LOG_DEBUG,
                          "192.0.2.1:1234",
                          &addr, &port, -1);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   tor_addr_to_str(buf, &addr, sizeof(buf), 0);
-  tt_str_op(buf,==, "192.0.2.1");
-  tt_int_op(port,==, 1234);
+  tt_str_op(buf,OP_EQ, "192.0.2.1");
+  tt_int_op(port,OP_EQ, 1234);
 
   r= tor_addr_port_parse(LOG_DEBUG,
                          "[::1]:1234",
                          &addr, &port, -1);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   tor_addr_to_str(buf, &addr, sizeof(buf), 0);
-  tt_str_op(buf,==, "::1");
-  tt_int_op(port,==, 1234);
+  tt_str_op(buf,OP_EQ, "::1");
+  tt_int_op(port,OP_EQ, 1234);
 
   /* Domain name. */
   r= tor_addr_port_parse(LOG_DEBUG,
                          "torproject.org:1234",
                          &addr, &port, -1);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
 
   /* Only IP. */
   r= tor_addr_port_parse(LOG_DEBUG,
                          "192.0.2.2",
                          &addr, &port, -1);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
 
   r= tor_addr_port_parse(LOG_DEBUG,
                          "192.0.2.2",
                          &addr, &port, 200);
-  tt_int_op(r, ==, 0);
-  tt_int_op(port,==,200);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(port,OP_EQ,200);
 
   r= tor_addr_port_parse(LOG_DEBUG,
                          "[::1]",
                          &addr, &port, -1);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
 
   r= tor_addr_port_parse(LOG_DEBUG,
                          "[::1]",
                          &addr, &port, 400);
-  tt_int_op(r, ==, 0);
-  tt_int_op(port,==,400);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(port,OP_EQ,400);
 
   /* Bad port. */
   r= tor_addr_port_parse(LOG_DEBUG,
                          "192.0.2.2:66666",
                          &addr, &port, -1);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
   r= tor_addr_port_parse(LOG_DEBUG,
                          "192.0.2.2:66666",
                          &addr, &port, 200);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
 
   /* Only domain name */
   r= tor_addr_port_parse(LOG_DEBUG,
                          "torproject.org",
                          &addr, &port, -1);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
   r= tor_addr_port_parse(LOG_DEBUG,
                          "torproject.org",
                          &addr, &port, 200);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
 
   /* Bad IP address */
   r= tor_addr_port_parse(LOG_DEBUG,
                          "192.0.2:1234",
                          &addr, &port, -1);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -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);
-  tt_int_op(r, ==, 0);
-  tt_int_op(port,==,1337);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(port,OP_EQ,1337);
 
   r= tor_addr_port_parse(LOG_DEBUG,
                          "[::1]:1369",
                          &addr, &port, 200);
-  tt_int_op(r, ==, 0);
-  tt_int_op(port,==,1369);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(port,OP_EQ,1369);
 
  done:
   ;
@@ -886,7 +886,7 @@ test_virtaddrmap(void *data)
         get_random_virtual_addr(&cfg[ipv6], &a);
         //printf("%s\n", fmt_addr(&a));
         /* Make sure that the first b bits match the configured network */
-        tt_int_op(0, ==, tor_addr_compare_masked(&a, &cfg[ipv6].addr,
+        tt_int_op(0, OP_EQ, tor_addr_compare_masked(&a, &cfg[ipv6].addr,
                                                  bits, CMP_EXACT));
 
         /* And track which bits have been different between pairs of
@@ -930,7 +930,7 @@ test_addr_dup_ip(void *arg)
   (void)arg;
 #define CHECK(ip, s) do {                         \
     v = tor_dup_ip(ip);                           \
-    tt_str_op(v,==,(s));                          \
+    tt_str_op(v,OP_EQ,(s));                          \
     tor_free(v);                                  \
   } while (0)
 
@@ -956,7 +956,7 @@ test_addr_sockaddr_to_str(void *arg)
 #endif
 #define CHECK(sa, s) do {                                       \
     v = tor_sockaddr_to_str((const struct sockaddr*) &(sa));    \
-    tt_str_op(v,==,(s));                                        \
+    tt_str_op(v,OP_EQ,(s));                                        \
     tor_free(v);                                                \
   } while (0)
   (void)arg;
@@ -1013,12 +1013,12 @@ test_addr_is_loopback(void *data)
   (void)data;
 
   for (i=0; loopback_items[i].name; ++i) {
-    tt_int_op(tor_addr_parse(&addr, loopback_items[i].name), >=, 0);
-    tt_int_op(tor_addr_is_loopback(&addr), ==, loopback_items[i].is_loopback);
+    tt_int_op(tor_addr_parse(&addr, loopback_items[i].name), OP_GE, 0);
+    tt_int_op(tor_addr_is_loopback(&addr), OP_EQ, loopback_items[i].is_loopback);
   }
 
   tor_addr_make_unspec(&addr);
-  tt_int_op(tor_addr_is_loopback(&addr), ==, 0);
+  tt_int_op(tor_addr_is_loopback(&addr), OP_EQ, 0);
 
  done:
   ;
@@ -1033,18 +1033,18 @@ test_addr_make_null(void *data)
   (void) data;
   /* Ensure that before tor_addr_make_null, addr != 0's */
   memset(addr, 1, sizeof(*addr));
-  tt_int_op(memcmp(addr, zeros, sizeof(*addr)), !=, 0);
+  tt_int_op(memcmp(addr, zeros, sizeof(*addr)), OP_NE, 0);
   /* Test with AF == AF_INET */
   zeros->family = AF_INET;
   tor_addr_make_null(addr, AF_INET);
-  tt_int_op(memcmp(addr, zeros, sizeof(*addr)), ==, 0);
-  tt_str_op(tor_addr_to_str(buf, addr, sizeof(buf), 0), ==, "0.0.0.0");
+  tt_int_op(memcmp(addr, zeros, sizeof(*addr)), OP_EQ, 0);
+  tt_str_op(tor_addr_to_str(buf, addr, sizeof(buf), 0), OP_EQ, "0.0.0.0");
   /* Test with AF == AF_INET6 */
   memset(addr, 1, sizeof(*addr));
   zeros->family = AF_INET6;
   tor_addr_make_null(addr, AF_INET6);
-  tt_int_op(memcmp(addr, zeros, sizeof(*addr)), ==, 0);
-  tt_str_op(tor_addr_to_str(buf, addr, sizeof(buf), 0), ==, "::");
+  tt_int_op(memcmp(addr, zeros, sizeof(*addr)), OP_EQ, 0);
+  tt_str_op(tor_addr_to_str(buf, addr, sizeof(buf), 0), OP_EQ, "::");
  done:
   tor_free(addr);
   tor_free(zeros);
diff --git a/src/test/test_buffers.c b/src/test/test_buffers.c
index cea7190..7e42124 100644
--- a/src/test/test_buffers.c
+++ b/src/test/test_buffers.c
@@ -30,7 +30,7 @@ test_buffers_basic(void *arg)
     TT_DIE(("Assertion failed."));
 
   //test_eq(buf_capacity(buf), 4096);
-  tt_int_op(buf_datalen(buf),==, 0);
+  tt_int_op(buf_datalen(buf),OP_EQ, 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);
-  tt_int_op(buf_datalen(buf),==, 512);
+  tt_int_op(buf_datalen(buf),OP_EQ, 512);
   fetch_from_buf(str2, 200, buf);
-  tt_mem_op(str,==, str2, 200);
-  tt_int_op(buf_datalen(buf),==, 312);
+  tt_mem_op(str,OP_EQ, str2, 200);
+  tt_int_op(buf_datalen(buf),OP_EQ, 312);
   memset(str2, 0, sizeof(str2));
 
   fetch_from_buf(str2, 256, buf);
-  tt_mem_op(str+200,==, str2, 56);
-  tt_mem_op(str,==, str2+56, 200);
-  tt_int_op(buf_datalen(buf),==, 56);
+  tt_mem_op(str+200,OP_EQ, str2, 56);
+  tt_mem_op(str,OP_EQ, str2+56, 200);
+  tt_int_op(buf_datalen(buf),OP_EQ, 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);
-  tt_int_op(buf_datalen(buf),==, 3896);
+  tt_int_op(buf_datalen(buf),OP_EQ, 3896);
   fetch_from_buf(str2, 56, buf);
-  tt_int_op(buf_datalen(buf),==, 3840);
-  tt_mem_op(str+200,==, str2, 56);
+  tt_int_op(buf_datalen(buf),OP_EQ, 3840);
+  tt_mem_op(str+200,OP_EQ, str2, 56);
   for (j=0;j<15;++j) {
     memset(str2, 0, sizeof(str2));
     fetch_from_buf(str2, 256, buf);
-    tt_mem_op(str,==, str2, 256);
+    tt_mem_op(str,OP_EQ, str2, 256);
   }
-  tt_int_op(buf_datalen(buf),==, 0);
+  tt_int_op(buf_datalen(buf),OP_EQ, 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);
-  tt_mem_op(str+1,==, str2, 254);
+  tt_mem_op(str+1,OP_EQ, 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);
-  tt_int_op(buf_datalen(buf),==, 33+256);
+  tt_int_op(buf_datalen(buf),OP_EQ, 33+256);
   fetch_from_buf(str2, 33, buf);
-  tt_int_op(*str2,==, str[255]);
+  tt_int_op(*str2,OP_EQ, str[255]);
 
-  tt_mem_op(str2+1,==, str, 32);
+  tt_mem_op(str2+1,OP_EQ, str, 32);
   //test_eq(buf_capacity(buf), 512);
-  tt_int_op(buf_datalen(buf),==, 256);
+  tt_int_op(buf_datalen(buf),OP_EQ, 256);
   fetch_from_buf(str2, 256, buf);
-  tt_mem_op(str,==, str2, 256);
+  tt_mem_op(str,OP_EQ, 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);
-  tt_int_op(buf_datalen(buf),==, 17085);
+  tt_int_op(buf_datalen(buf),OP_EQ, 17085);
   for (j=0; j < 40; ++j) {
     fetch_from_buf(str2, 255,buf);
-    tt_mem_op(str2,==, str, 255);
+    tt_mem_op(str2,OP_EQ, 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);
-    tt_mem_op(str2,==, str, 255);
+    tt_mem_op(str2,OP_EQ, 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);
-    tt_mem_op(str2,==, str, 255);
+    tt_mem_op(str2,OP_EQ, 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);
-  tt_int_op(buf_datalen(buf),==, 25500);
+  tt_int_op(buf_datalen(buf),OP_EQ, 25500);
   for (j=0;j<100;++j) {
     r = 10;
     move_buf_to_buf(buf2, buf, &r);
-    tt_int_op(r,==, 0);
+    tt_int_op(r,OP_EQ, 0);
   }
-  tt_int_op(buf_datalen(buf),==, 24500);
-  tt_int_op(buf_datalen(buf2),==, 1000);
+  tt_int_op(buf_datalen(buf),OP_EQ, 24500);
+  tt_int_op(buf_datalen(buf2),OP_EQ, 1000);
   for (j=0;j<3;++j) {
     fetch_from_buf(str2, 255, buf2);
-    tt_mem_op(str2,==, str, 255);
+    tt_mem_op(str2,OP_EQ, str, 255);
   }
   r = 8192; /*big move*/
   move_buf_to_buf(buf2, buf, &r);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
   r = 30000; /* incomplete move */
   move_buf_to_buf(buf2, buf, &r);
-  tt_int_op(r,==, 13692);
+  tt_int_op(r,OP_EQ, 13692);
   for (j=0;j<97;++j) {
     fetch_from_buf(str2, 255, buf2);
-    tt_mem_op(str2,==, str, 255);
+    tt_mem_op(str2,OP_EQ, 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);
-  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));
+  tt_int_op(0,OP_EQ, buf_find_string_offset(buf, "Testing", 7));
+  tt_int_op(1,OP_EQ, buf_find_string_offset(buf, "esting", 6));
+  tt_int_op(1,OP_EQ, buf_find_string_offset(buf, "est", 3));
+  tt_int_op(39,OP_EQ, buf_find_string_offset(buf, "ing str", 7));
+  tt_int_op(35,OP_EQ, buf_find_string_offset(buf, "Testing str", 11));
+  tt_int_op(32,OP_EQ, buf_find_string_offset(buf, "ng ", 3));
+  tt_int_op(43,OP_EQ, buf_find_string_offset(buf, "string.", 7));
+  tt_int_op(-1,OP_EQ, buf_find_string_offset(buf, "shrdlu", 6));
+  tt_int_op(-1,OP_EQ, buf_find_string_offset(buf, "Testing thing", 13));
+  tt_int_op(-1,OP_EQ, buf_find_string_offset(buf, "ngx", 3));
   buf_free(buf);
   buf = NULL;
 
@@ -183,7 +183,7 @@ test_buffers_basic(void *arg)
     write_to_buf(cp, 65536, buf);
     tor_free(cp);
 
-    tt_int_op(buf_datalen(buf), ==, 65536);
+    tt_int_op(buf_datalen(buf), OP_EQ, 65536);
     buf_free(buf);
     buf = NULL;
   }
@@ -213,19 +213,19 @@ test_buffer_pullup(void *arg)
   buf = buf_new_with_capacity(3000); /* rounds up to next power of 2. */
 
   tt_assert(buf);
-  tt_int_op(buf_get_default_chunk_size(buf), ==, 4096);
+  tt_int_op(buf_get_default_chunk_size(buf), OP_EQ, 4096);
 
-  tt_int_op(buf_get_total_allocation(), ==, 0);
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 0);
 
   /* There are a bunch of cases for pullup.  One is the trivial case. Let's
      mess around with an empty buffer. */
   buf_pullup(buf, 16, 1);
   buf_get_first_chunk_data(buf, &cp, &sz);
-  tt_ptr_op(cp, ==, NULL);
-  tt_uint_op(sz, ==, 0);
+  tt_ptr_op(cp, OP_EQ, NULL);
+  tt_uint_op(sz, OP_EQ, 0);
 
   /* Let's make sure nothing got allocated */
-  tt_int_op(buf_get_total_allocation(), ==, 0);
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 0);
 
   /* Case 1: everything puts into the first chunk with some moving. */
 
@@ -234,22 +234,22 @@ test_buffer_pullup(void *arg)
   write_to_buf(stuff, 3000, buf);
   write_to_buf(stuff+3000, 3000, buf);
   buf_get_first_chunk_data(buf, &cp, &sz);
-  tt_ptr_op(cp, !=, NULL);
-  tt_int_op(sz, <=, 4096);
+  tt_ptr_op(cp, OP_NE, NULL);
+  tt_int_op(sz, OP_LE, 4096);
 
   /* 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);
-  tt_mem_op(tmp,==, stuff, 3000);
+  tt_int_op(fetch_from_buf(tmp, 3000, buf), OP_EQ, 3000);
+  tt_mem_op(tmp,OP_EQ, 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);
-  tt_mem_op(cp,==, stuff+3000, 2048);
-  tt_int_op(3000, ==, buf_datalen(buf));
-  tt_int_op(fetch_from_buf(tmp, 3000, buf), ==, 0);
-  tt_mem_op(tmp,==, stuff+3000, 2048);
+  tt_ptr_op(cp, OP_NE, NULL);
+  tt_int_op(sz, OP_GE, 2048);
+  tt_mem_op(cp,OP_EQ, stuff+3000, 2048);
+  tt_int_op(3000, OP_EQ, buf_datalen(buf));
+  tt_int_op(fetch_from_buf(tmp, 3000, buf), OP_EQ, 0);
+  tt_mem_op(tmp,OP_EQ, stuff+3000, 2048);
 
   buf_free(buf);
 
@@ -259,26 +259,26 @@ test_buffer_pullup(void *arg)
   write_to_buf(stuff+4000, 4000, buf);
   write_to_buf(stuff+8000, 4000, buf);
   write_to_buf(stuff+12000, 4000, buf);
-  tt_int_op(buf_datalen(buf), ==, 16000);
+  tt_int_op(buf_datalen(buf), OP_EQ, 16000);
   buf_get_first_chunk_data(buf, &cp, &sz);
-  tt_ptr_op(cp, !=, NULL);
-  tt_int_op(sz, <=, 4096);
+  tt_ptr_op(cp, OP_NE, NULL);
+  tt_int_op(sz, OP_LE, 4096);
 
   buf_pullup(buf, 12500, 0);
   assert_buf_ok(buf);
   buf_get_first_chunk_data(buf, &cp, &sz);
-  tt_ptr_op(cp, !=, NULL);
-  tt_int_op(sz, >=, 12500);
-  tt_mem_op(cp,==, stuff, 12500);
-  tt_int_op(buf_datalen(buf), ==, 16000);
+  tt_ptr_op(cp, OP_NE, NULL);
+  tt_int_op(sz, OP_GE, 12500);
+  tt_mem_op(cp,OP_EQ, stuff, 12500);
+  tt_int_op(buf_datalen(buf), OP_EQ, 16000);
 
   fetch_from_buf(tmp, 12400, buf);
-  tt_mem_op(tmp,==, stuff, 12400);
-  tt_int_op(buf_datalen(buf), ==, 3600);
+  tt_mem_op(tmp,OP_EQ, stuff, 12400);
+  tt_int_op(buf_datalen(buf), OP_EQ, 3600);
   fetch_from_buf(tmp, 3500, buf);
-  tt_mem_op(tmp,==, stuff+12400, 3500);
+  tt_mem_op(tmp,OP_EQ, stuff+12400, 3500);
   fetch_from_buf(tmp, 100, buf);
-  tt_mem_op(tmp,==, stuff+15900, 10);
+  tt_mem_op(tmp,OP_EQ, stuff+15900, 10);
 
   buf_free(buf);
 
@@ -290,16 +290,16 @@ test_buffer_pullup(void *arg)
   buf_pullup(buf, 16000, 0); /* Way too much. */
   assert_buf_ok(buf);
   buf_get_first_chunk_data(buf, &cp, &sz);
-  tt_ptr_op(cp, !=, NULL);
-  tt_int_op(sz, ==, 7900);
-  tt_mem_op(cp,==, stuff+100, 7900);
+  tt_ptr_op(cp, OP_NE, NULL);
+  tt_int_op(sz, OP_EQ, 7900);
+  tt_mem_op(cp,OP_EQ, stuff+100, 7900);
 
   buf_free(buf);
   buf = NULL;
 
   buf_shrink_freelists(1);
 
-  tt_int_op(buf_get_total_allocation(), ==, 0);
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 0);
  done:
   buf_free(buf);
   buf_shrink_freelists(1);
@@ -321,31 +321,31 @@ test_buffer_copy(void *arg)
   tt_assert(buf);
 
   /* Copy an empty buffer. */
-  tt_int_op(0, ==, generic_buffer_set_to_copy(&buf2, buf));
+  tt_int_op(0, OP_EQ, generic_buffer_set_to_copy(&buf2, buf));
   tt_assert(buf2);
-  tt_int_op(0, ==, generic_buffer_len(buf2));
+  tt_int_op(0, OP_EQ, generic_buffer_len(buf2));
 
   /* Now try with a short buffer. */
   s = "And now comes an act of enormous enormance!";
   len = strlen(s);
   generic_buffer_add(buf, s, len);
-  tt_int_op(len, ==, generic_buffer_len(buf));
+  tt_int_op(len, OP_EQ, generic_buffer_len(buf));
   /* Add junk to buf2 so we can test replacing.*/
   generic_buffer_add(buf2, "BLARG", 5);
-  tt_int_op(0, ==, generic_buffer_set_to_copy(&buf2, buf));
-  tt_int_op(len, ==, generic_buffer_len(buf2));
+  tt_int_op(0, OP_EQ, generic_buffer_set_to_copy(&buf2, buf));
+  tt_int_op(len, OP_EQ, generic_buffer_len(buf2));
   generic_buffer_get(buf2, b, len);
-  tt_mem_op(b, ==, s, len);
+  tt_mem_op(b, OP_EQ, 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));
+  tt_int_op(0, OP_EQ, generic_buffer_set_to_copy(&buf2, buf));
+  tt_int_op(len, OP_EQ, generic_buffer_len(buf2));
   generic_buffer_get(buf2, b, len);
-  tt_mem_op(b, ==, s, len);
+  tt_mem_op(b, OP_EQ, s, len);
   /* Clear buf for next test */
   generic_buffer_get(buf, b, len);
-  tt_int_op(generic_buffer_len(buf),==,0);
+  tt_int_op(generic_buffer_len(buf),OP_EQ,0);
 
   /* Okay, now let's try a bigger buffer. */
   s = "Quis autem vel eum iure reprehenderit qui in ea voluptate velit "
@@ -357,12 +357,12 @@ test_buffer_copy(void *arg)
     generic_buffer_add(buf, b, 1);
     generic_buffer_add(buf, s, len);
   }
-  tt_int_op(0, ==, generic_buffer_set_to_copy(&buf2, buf));
-  tt_int_op(generic_buffer_len(buf2), ==, generic_buffer_len(buf));
+  tt_int_op(0, OP_EQ, generic_buffer_set_to_copy(&buf2, buf));
+  tt_int_op(generic_buffer_len(buf2), OP_EQ, generic_buffer_len(buf));
   for (i = 0; i < 256; ++i) {
     generic_buffer_get(buf2, b, len+1);
-    tt_int_op((unsigned char)b[0],==,i);
-    tt_mem_op(b+1, ==, s, len);
+    tt_int_op((unsigned char)b[0],OP_EQ,i);
+    tt_mem_op(b+1, OP_EQ, s, len);
   }
 
  done:
@@ -382,62 +382,62 @@ test_buffer_ext_or_cmd(void *arg)
   (void) arg;
 
   /* Empty -- should give "not there. */
-  tt_int_op(0, ==, generic_buffer_fetch_ext_or_cmd(buf, &cmd));
-  tt_ptr_op(NULL, ==, cmd);
+  tt_int_op(0, OP_EQ, generic_buffer_fetch_ext_or_cmd(buf, &cmd));
+  tt_ptr_op(NULL, OP_EQ, cmd);
 
   /* Three bytes: shouldn't work. */
   generic_buffer_add(buf, "\x00\x20\x00", 3);
-  tt_int_op(0, ==, generic_buffer_fetch_ext_or_cmd(buf, &cmd));
-  tt_ptr_op(NULL, ==, cmd);
-  tt_int_op(3, ==, generic_buffer_len(buf));
+  tt_int_op(0, OP_EQ, generic_buffer_fetch_ext_or_cmd(buf, &cmd));
+  tt_ptr_op(NULL, OP_EQ, cmd);
+  tt_int_op(3, OP_EQ, generic_buffer_len(buf));
 
   /* 0020 0000: That's a nil command. It should work. */
   generic_buffer_add(buf, "\x00", 1);
-  tt_int_op(1, ==, generic_buffer_fetch_ext_or_cmd(buf, &cmd));
-  tt_ptr_op(NULL, !=, cmd);
-  tt_int_op(0x20, ==, cmd->cmd);
-  tt_int_op(0, ==, cmd->len);
-  tt_int_op(0, ==, generic_buffer_len(buf));
+  tt_int_op(1, OP_EQ, generic_buffer_fetch_ext_or_cmd(buf, &cmd));
+  tt_ptr_op(NULL, OP_NE, cmd);
+  tt_int_op(0x20, OP_EQ, cmd->cmd);
+  tt_int_op(0, OP_EQ, cmd->len);
+  tt_int_op(0, OP_EQ, generic_buffer_len(buf));
   ext_or_cmd_free(cmd);
   cmd = NULL;
 
   /* Now try a length-6 command with one byte missing. */
   generic_buffer_add(buf, "\x10\x21\x00\x06""abcde", 9);
-  tt_int_op(0, ==, generic_buffer_fetch_ext_or_cmd(buf, &cmd));
-  tt_ptr_op(NULL, ==, cmd);
+  tt_int_op(0, OP_EQ, generic_buffer_fetch_ext_or_cmd(buf, &cmd));
+  tt_ptr_op(NULL, OP_EQ, cmd);
   generic_buffer_add(buf, "f", 1);
-  tt_int_op(1, ==, generic_buffer_fetch_ext_or_cmd(buf, &cmd));
-  tt_ptr_op(NULL, !=, cmd);
-  tt_int_op(0x1021, ==, cmd->cmd);
-  tt_int_op(6, ==, cmd->len);
-  tt_mem_op("abcdef", ==, cmd->body, 6);
-  tt_int_op(0, ==, generic_buffer_len(buf));
+  tt_int_op(1, OP_EQ, generic_buffer_fetch_ext_or_cmd(buf, &cmd));
+  tt_ptr_op(NULL, OP_NE, cmd);
+  tt_int_op(0x1021, OP_EQ, cmd->cmd);
+  tt_int_op(6, OP_EQ, cmd->len);
+  tt_mem_op("abcdef", OP_EQ, cmd->body, 6);
+  tt_int_op(0, OP_EQ, generic_buffer_len(buf));
   ext_or_cmd_free(cmd);
   cmd = NULL;
 
   /* Now try a length-10 command with 4 extra bytes. */
   generic_buffer_add(buf, "\xff\xff\x00\x0a"
                      "loremipsum\x10\x00\xff\xff", 18);
-  tt_int_op(1, ==, generic_buffer_fetch_ext_or_cmd(buf, &cmd));
-  tt_ptr_op(NULL, !=, cmd);
-  tt_int_op(0xffff, ==, cmd->cmd);
-  tt_int_op(10, ==, cmd->len);
-  tt_mem_op("loremipsum", ==, cmd->body, 10);
-  tt_int_op(4, ==, generic_buffer_len(buf));
+  tt_int_op(1, OP_EQ, generic_buffer_fetch_ext_or_cmd(buf, &cmd));
+  tt_ptr_op(NULL, OP_NE, cmd);
+  tt_int_op(0xffff, OP_EQ, cmd->cmd);
+  tt_int_op(10, OP_EQ, cmd->len);
+  tt_mem_op("loremipsum", OP_EQ, cmd->body, 10);
+  tt_int_op(4, OP_EQ, generic_buffer_len(buf));
   ext_or_cmd_free(cmd);
   cmd = NULL;
 
   /* Finally, let's try a maximum-length command. We already have the header
    * waiting. */
-  tt_int_op(0, ==, generic_buffer_fetch_ext_or_cmd(buf, &cmd));
+  tt_int_op(0, OP_EQ, generic_buffer_fetch_ext_or_cmd(buf, &cmd));
   tmp = tor_malloc_zero(65535);
   generic_buffer_add(buf, tmp, 65535);
-  tt_int_op(1, ==, generic_buffer_fetch_ext_or_cmd(buf, &cmd));
-  tt_ptr_op(NULL, !=, cmd);
-  tt_int_op(0x1000, ==, cmd->cmd);
-  tt_int_op(0xffff, ==, cmd->len);
-  tt_mem_op(tmp, ==, cmd->body, 65535);
-  tt_int_op(0, ==, generic_buffer_len(buf));
+  tt_int_op(1, OP_EQ, generic_buffer_fetch_ext_or_cmd(buf, &cmd));
+  tt_ptr_op(NULL, OP_NE, cmd);
+  tt_int_op(0x1000, OP_EQ, cmd->cmd);
+  tt_int_op(0xffff, OP_EQ, cmd->len);
+  tt_mem_op(tmp, OP_EQ, cmd->body, 65535);
+  tt_int_op(0, OP_EQ, generic_buffer_len(buf));
   ext_or_cmd_free(cmd);
   cmd = NULL;
 
@@ -458,65 +458,65 @@ test_buffer_allocation_tracking(void *arg)
   (void)arg;
 
   crypto_rand(junk, 16384);
-  tt_int_op(buf_get_total_allocation(), ==, 0);
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 0);
 
   buf1 = buf_new();
   tt_assert(buf1);
   buf2 = buf_new();
   tt_assert(buf2);
 
-  tt_int_op(buf_allocation(buf1), ==, 0);
-  tt_int_op(buf_get_total_allocation(), ==, 0);
+  tt_int_op(buf_allocation(buf1), OP_EQ, 0);
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 0);
 
   write_to_buf(junk, 4000, buf1);
   write_to_buf(junk, 4000, buf1);
   write_to_buf(junk, 4000, buf1);
   write_to_buf(junk, 4000, buf1);
-  tt_int_op(buf_allocation(buf1), ==, 16384);
+  tt_int_op(buf_allocation(buf1), OP_EQ, 16384);
   fetch_from_buf(junk, 100, buf1);
-  tt_int_op(buf_allocation(buf1), ==, 16384); /* still 4 4k chunks */
+  tt_int_op(buf_allocation(buf1), OP_EQ, 16384); /* still 4 4k chunks */
 
-  tt_int_op(buf_get_total_allocation(), ==, 16384);
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 16384);
 
   fetch_from_buf(junk, 4096, buf1); /* drop a 1k chunk... */
-  tt_int_op(buf_allocation(buf1), ==, 3*4096); /* now 3 4k chunks */
+  tt_int_op(buf_allocation(buf1), OP_EQ, 3*4096); /* now 3 4k chunks */
 
 #ifdef ENABLE_BUF_FREELISTS
-  tt_int_op(buf_get_total_allocation(), ==, 16384); /* that chunk went onto
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 16384); /* that chunk went onto
                                                        the freelist. */
 #else
-  tt_int_op(buf_get_total_allocation(), ==, 12288); /* that chunk was really
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 12288); /* that chunk was really
                                                        freed. */
 #endif
 
   write_to_buf(junk, 4000, buf2);
-  tt_int_op(buf_allocation(buf2), ==, 4096); /* another 4k chunk. */
+  tt_int_op(buf_allocation(buf2), OP_EQ, 4096); /* another 4k chunk. */
   /*
    * If we're using freelists, size stays at 16384 because we just pulled a
    * chunk from the freelist.  If we aren't, we bounce back up to 16384 by
    * allocating a new chunk.
    */
-  tt_int_op(buf_get_total_allocation(), ==, 16384);
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 16384);
   write_to_buf(junk, 4000, buf2);
-  tt_int_op(buf_allocation(buf2), ==, 8192); /* another 4k chunk. */
-  tt_int_op(buf_get_total_allocation(), ==, 5*4096); /* that chunk was new. */
+  tt_int_op(buf_allocation(buf2), OP_EQ, 8192); /* another 4k chunk. */
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 5*4096); /* that chunk was new. */
 
   /* Make a really huge buffer */
   for (i = 0; i < 1000; ++i) {
     write_to_buf(junk, 4000, buf2);
   }
-  tt_int_op(buf_allocation(buf2), >=, 4008000);
-  tt_int_op(buf_get_total_allocation(), >=, 4008000);
+  tt_int_op(buf_allocation(buf2), OP_GE, 4008000);
+  tt_int_op(buf_get_total_allocation(), OP_GE, 4008000);
   buf_free(buf2);
   buf2 = NULL;
 
-  tt_int_op(buf_get_total_allocation(), <, 4008000);
+  tt_int_op(buf_get_total_allocation(), OP_LT, 4008000);
   buf_shrink_freelists(1);
-  tt_int_op(buf_get_total_allocation(), ==, buf_allocation(buf1));
+  tt_int_op(buf_get_total_allocation(), OP_EQ, buf_allocation(buf1));
   buf_free(buf1);
   buf1 = NULL;
   buf_shrink_freelists(1);
-  tt_int_op(buf_get_total_allocation(), ==, 0);
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 0);
 
  done:
   buf_free(buf1);
@@ -545,37 +545,37 @@ test_buffer_time_tracking(void *arg)
   tt_assert(buf);
 
   /* Empty buffer means the timestamp is 0. */
-  tt_int_op(0, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC));
-  tt_int_op(0, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC+1000));
+  tt_int_op(0, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC));
+  tt_int_op(0, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+1000));
 
   tor_gettimeofday_cache_set(&tv0);
   write_to_buf("ABCDEFG", 7, buf);
-  tt_int_op(1000, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC+1000));
+  tt_int_op(1000, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+1000));
 
   buf2 = buf_copy(buf);
   tt_assert(buf2);
-  tt_int_op(1234, ==, buf_get_oldest_chunk_timestamp(buf2, START_MSEC+1234));
+  tt_int_op(1234, OP_EQ, buf_get_oldest_chunk_timestamp(buf2, START_MSEC+1234));
 
   /* Now add more bytes; enough to overflow the first chunk. */
   tv0.tv_usec += 123 * 1000;
   tor_gettimeofday_cache_set(&tv0);
   for (i = 0; i < 600; ++i)
     write_to_buf("ABCDEFG", 7, buf);
-  tt_int_op(4207, ==, buf_datalen(buf));
+  tt_int_op(4207, OP_EQ, buf_datalen(buf));
 
   /* The oldest bytes are still in the front. */
-  tt_int_op(2000, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2000));
+  tt_int_op(2000, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2000));
 
   /* Once those bytes are dropped, the chunk is still on the first
    * timestamp. */
   fetch_from_buf(tmp, 100, buf);
-  tt_int_op(2000, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2000));
+  tt_int_op(2000, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2000));
 
   /* But once we discard the whole first chunk, we get the data in the second
    * chunk. */
   fetch_from_buf(tmp, 4000, buf);
-  tt_int_op(107, ==, buf_datalen(buf));
-  tt_int_op(2000, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2123));
+  tt_int_op(107, OP_EQ, buf_datalen(buf));
+  tt_int_op(2000, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2123));
 
   /* This time we'll be grabbing a chunk from the freelist, and making sure
      its time gets updated */
@@ -584,13 +584,13 @@ test_buffer_time_tracking(void *arg)
   tor_gettimeofday_cache_set(&tv0);
   for (i = 0; i < 600; ++i)
     write_to_buf("ABCDEFG", 7, buf);
-  tt_int_op(4307, ==, buf_datalen(buf));
+  tt_int_op(4307, OP_EQ, buf_datalen(buf));
 
-  tt_int_op(2000, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2123));
+  tt_int_op(2000, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2123));
   fetch_from_buf(tmp, 4000, buf);
   fetch_from_buf(tmp, 306, buf);
-  tt_int_op(0, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC+5617));
-  tt_int_op(383, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC+6000));
+  tt_int_op(0, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+5617));
+  tt_int_op(383, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+6000));
 
  done:
   buf_free(buf);
@@ -613,31 +613,31 @@ test_buffers_zlib_impl(int finalize_with_nil)
 
   msg = tor_malloc(512);
   crypto_rand(msg, 512);
-  tt_int_op(write_to_buf_zlib(buf, zlib_state, msg, 128, 0), ==, 0);
-  tt_int_op(write_to_buf_zlib(buf, zlib_state, msg+128, 128, 0), ==, 0);
-  tt_int_op(write_to_buf_zlib(buf, zlib_state, msg+256, 256, 0), ==, 0);
+  tt_int_op(write_to_buf_zlib(buf, zlib_state, msg, 128, 0), OP_EQ, 0);
+  tt_int_op(write_to_buf_zlib(buf, zlib_state, msg+128, 128, 0), OP_EQ, 0);
+  tt_int_op(write_to_buf_zlib(buf, zlib_state, msg+256, 256, 0), OP_EQ, 0);
   done = !finalize_with_nil;
-  tt_int_op(write_to_buf_zlib(buf, zlib_state, "all done", 9, done), ==, 0);
+  tt_int_op(write_to_buf_zlib(buf, zlib_state, "all done", 9, done), OP_EQ, 0);
   if (finalize_with_nil) {
-    tt_int_op(write_to_buf_zlib(buf, zlib_state, "", 0, 1), ==, 0);
+    tt_int_op(write_to_buf_zlib(buf, zlib_state, "", 0, 1), OP_EQ, 0);
   }
 
   in_len = buf_datalen(buf);
   contents = tor_malloc(in_len);
 
-  tt_int_op(fetch_from_buf(contents, in_len, buf), ==, 0);
+  tt_int_op(fetch_from_buf(contents, in_len, buf), OP_EQ, 0);
 
-  tt_int_op(0, ==, tor_gzip_uncompress(&expanded, &out_len,
+  tt_int_op(0, OP_EQ, tor_gzip_uncompress(&expanded, &out_len,
                                        contents, in_len,
                                        ZLIB_METHOD, 1,
                                        LOG_WARN));
 
-  tt_int_op(out_len, >=, 128);
-  tt_mem_op(msg, ==, expanded, 128);
-  tt_int_op(out_len, >=, 512);
-  tt_mem_op(msg, ==, expanded, 512);
-  tt_int_op(out_len, ==, 512+9);
-  tt_mem_op("all done", ==, expanded+512, 9);
+  tt_int_op(out_len, OP_GE, 128);
+  tt_mem_op(msg, OP_EQ, expanded, 128);
+  tt_int_op(out_len, OP_GE, 512);
+  tt_mem_op(msg, OP_EQ, expanded, 512);
+  tt_int_op(out_len, OP_EQ, 512+9);
+  tt_mem_op("all done", OP_EQ, expanded+512, 9);
 
  done:
   buf_free(buf);
@@ -680,28 +680,28 @@ test_buffers_zlib_fin_at_chunk_end(void *arg)
   tt_assert(buf->head);
 
   /* Fill up the chunk so the zlib stuff won't fit in one chunk. */
-  tt_uint_op(buf->head->memlen, <, sz);
+  tt_uint_op(buf->head->memlen, OP_LT, sz);
   headerjunk = buf->head->memlen - 7;
   write_to_buf(msg, headerjunk-1, buf);
-  tt_uint_op(buf->head->datalen, ==, headerjunk);
-  tt_uint_op(buf_datalen(buf), ==, headerjunk);
+  tt_uint_op(buf->head->datalen, OP_EQ, headerjunk);
+  tt_uint_op(buf_datalen(buf), OP_EQ, headerjunk);
   /* Write an empty string, with finalization on. */
   zlib_state = tor_zlib_new(1, ZLIB_METHOD);
-  tt_int_op(write_to_buf_zlib(buf, zlib_state, "", 0, 1), ==, 0);
+  tt_int_op(write_to_buf_zlib(buf, zlib_state, "", 0, 1), OP_EQ, 0);
 
   in_len = buf_datalen(buf);
   contents = tor_malloc(in_len);
 
-  tt_int_op(fetch_from_buf(contents, in_len, buf), ==, 0);
+  tt_int_op(fetch_from_buf(contents, in_len, buf), OP_EQ, 0);
 
-  tt_uint_op(in_len, >, headerjunk);
+  tt_uint_op(in_len, OP_GT, headerjunk);
 
-  tt_int_op(0, ==, tor_gzip_uncompress(&expanded, &out_len,
+  tt_int_op(0, OP_EQ, tor_gzip_uncompress(&expanded, &out_len,
                                   contents + headerjunk, in_len - headerjunk,
                                   ZLIB_METHOD, 1,
                                   LOG_WARN));
 
-  tt_int_op(out_len, ==, 0);
+  tt_int_op(out_len, OP_EQ, 0);
   tt_assert(expanded);
 
  done:
diff --git a/src/test/test_cell_formats.c b/src/test/test_cell_formats.c
index 19ecedc..edc011f 100644
--- a/src/test/test_cell_formats.c
+++ b/src/test/test_cell_formats.c
@@ -30,16 +30,16 @@ test_cfmt_relay_header(void *arg)
   uint8_t hdr_out[RELAY_HEADER_SIZE];
   (void)arg;
 
-  tt_int_op(sizeof(hdr_1), ==, RELAY_HEADER_SIZE);
+  tt_int_op(sizeof(hdr_1), OP_EQ, RELAY_HEADER_SIZE);
   relay_header_unpack(&rh, hdr_1);
-  tt_int_op(rh.command, ==, 3);
-  tt_int_op(rh.recognized, ==, 0);
-  tt_int_op(rh.stream_id, ==, 0x2122);
-  tt_mem_op(rh.integrity, ==, "ABCD", 4);
-  tt_int_op(rh.length, ==, 0x103);
+  tt_int_op(rh.command, OP_EQ, 3);
+  tt_int_op(rh.recognized, OP_EQ, 0);
+  tt_int_op(rh.stream_id, OP_EQ, 0x2122);
+  tt_mem_op(rh.integrity, OP_EQ, "ABCD", 4);
+  tt_int_op(rh.length, OP_EQ, 0x103);
 
   relay_header_pack(hdr_out, &rh);
-  tt_mem_op(hdr_out, ==, hdr_1, RELAY_HEADER_SIZE);
+  tt_mem_op(hdr_out, OP_EQ, hdr_1, RELAY_HEADER_SIZE);
 
  done:
   ;
@@ -74,32 +74,32 @@ test_cfmt_begin_cells(void *arg)
   /* Try begindir. */
   memset(&bcell, 0x7f, sizeof(bcell));
   make_relay_cell(&cell, RELAY_COMMAND_BEGIN_DIR, "", 0);
-  tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason));
-  tt_ptr_op(NULL, ==, bcell.address);
-  tt_int_op(0, ==, bcell.flags);
-  tt_int_op(0, ==, bcell.port);
-  tt_int_op(5, ==, bcell.stream_id);
-  tt_int_op(1, ==, bcell.is_begindir);
+  tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_ptr_op(NULL, OP_EQ, bcell.address);
+  tt_int_op(0, OP_EQ, bcell.flags);
+  tt_int_op(0, OP_EQ, bcell.port);
+  tt_int_op(5, OP_EQ, bcell.stream_id);
+  tt_int_op(1, OP_EQ, bcell.is_begindir);
 
   /* A Begindir with extra stuff. */
   memset(&bcell, 0x7f, sizeof(bcell));
   make_relay_cell(&cell, RELAY_COMMAND_BEGIN_DIR, "12345", 5);
-  tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason));
-  tt_ptr_op(NULL, ==, bcell.address);
-  tt_int_op(0, ==, bcell.flags);
-  tt_int_op(0, ==, bcell.port);
-  tt_int_op(5, ==, bcell.stream_id);
-  tt_int_op(1, ==, bcell.is_begindir);
+  tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_ptr_op(NULL, OP_EQ, bcell.address);
+  tt_int_op(0, OP_EQ, bcell.flags);
+  tt_int_op(0, OP_EQ, bcell.port);
+  tt_int_op(5, OP_EQ, bcell.stream_id);
+  tt_int_op(1, OP_EQ, bcell.is_begindir);
 
   /* A short but valid begin cell */
   memset(&bcell, 0x7f, sizeof(bcell));
   make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "a.b:9", 6);
-  tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason));
-  tt_str_op("a.b", ==, bcell.address);
-  tt_int_op(0, ==, bcell.flags);
-  tt_int_op(9, ==, bcell.port);
-  tt_int_op(5, ==, bcell.stream_id);
-  tt_int_op(0, ==, bcell.is_begindir);
+  tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_str_op("a.b", OP_EQ, bcell.address);
+  tt_int_op(0, OP_EQ, bcell.flags);
+  tt_int_op(9, OP_EQ, bcell.port);
+  tt_int_op(5, OP_EQ, bcell.stream_id);
+  tt_int_op(0, OP_EQ, bcell.is_begindir);
   tor_free(bcell.address);
 
   /* A significantly loner begin cell */
@@ -108,35 +108,35 @@ test_cfmt_begin_cells(void *arg)
     const char c[] = "here-is-a-nice-long.hostname.com:65535";
     make_relay_cell(&cell, RELAY_COMMAND_BEGIN, c, strlen(c)+1);
   }
-  tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason));
-  tt_str_op("here-is-a-nice-long.hostname.com", ==, bcell.address);
-  tt_int_op(0, ==, bcell.flags);
-  tt_int_op(65535, ==, bcell.port);
-  tt_int_op(5, ==, bcell.stream_id);
-  tt_int_op(0, ==, bcell.is_begindir);
+  tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_str_op("here-is-a-nice-long.hostname.com", OP_EQ, bcell.address);
+  tt_int_op(0, OP_EQ, bcell.flags);
+  tt_int_op(65535, OP_EQ, bcell.port);
+  tt_int_op(5, OP_EQ, bcell.stream_id);
+  tt_int_op(0, OP_EQ, bcell.is_begindir);
   tor_free(bcell.address);
 
   /* An IPv4 begin cell. */
   memset(&bcell, 0x7f, sizeof(bcell));
   make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "18.9.22.169:80", 15);
-  tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason));
-  tt_str_op("18.9.22.169", ==, bcell.address);
-  tt_int_op(0, ==, bcell.flags);
-  tt_int_op(80, ==, bcell.port);
-  tt_int_op(5, ==, bcell.stream_id);
-  tt_int_op(0, ==, bcell.is_begindir);
+  tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_str_op("18.9.22.169", OP_EQ, bcell.address);
+  tt_int_op(0, OP_EQ, bcell.flags);
+  tt_int_op(80, OP_EQ, bcell.port);
+  tt_int_op(5, OP_EQ, bcell.stream_id);
+  tt_int_op(0, OP_EQ, bcell.is_begindir);
   tor_free(bcell.address);
 
   /* An IPv6 begin cell. Let's make sure we handle colons*/
   memset(&bcell, 0x7f, sizeof(bcell));
   make_relay_cell(&cell, RELAY_COMMAND_BEGIN,
                   "[2620::6b0:b:1a1a:0:26e5:480e]:80", 34);
-  tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason));
-  tt_str_op("[2620::6b0:b:1a1a:0:26e5:480e]", ==, bcell.address);
-  tt_int_op(0, ==, bcell.flags);
-  tt_int_op(80, ==, bcell.port);
-  tt_int_op(5, ==, bcell.stream_id);
-  tt_int_op(0, ==, bcell.is_begindir);
+  tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_str_op("[2620::6b0:b:1a1a:0:26e5:480e]", OP_EQ, bcell.address);
+  tt_int_op(0, OP_EQ, bcell.flags);
+  tt_int_op(80, OP_EQ, bcell.port);
+  tt_int_op(5, OP_EQ, bcell.stream_id);
+  tt_int_op(0, OP_EQ, bcell.is_begindir);
   tor_free(bcell.address);
 
   /* a begin cell with extra junk but not enough for flags. */
@@ -145,12 +145,12 @@ test_cfmt_begin_cells(void *arg)
     const char c[] = "another.example.com:80\x00\x01\x02";
     make_relay_cell(&cell, RELAY_COMMAND_BEGIN, c, sizeof(c)-1);
   }
-  tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason));
-  tt_str_op("another.example.com", ==, bcell.address);
-  tt_int_op(0, ==, bcell.flags);
-  tt_int_op(80, ==, bcell.port);
-  tt_int_op(5, ==, bcell.stream_id);
-  tt_int_op(0, ==, bcell.is_begindir);
+  tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_str_op("another.example.com", OP_EQ, bcell.address);
+  tt_int_op(0, OP_EQ, bcell.flags);
+  tt_int_op(80, OP_EQ, bcell.port);
+  tt_int_op(5, OP_EQ, bcell.stream_id);
+  tt_int_op(0, OP_EQ, bcell.is_begindir);
   tor_free(bcell.address);
 
   /* a begin cell with flags. */
@@ -159,12 +159,12 @@ test_cfmt_begin_cells(void *arg)
     const char c[] = "another.example.com:443\x00\x01\x02\x03\x04";
     make_relay_cell(&cell, RELAY_COMMAND_BEGIN, c, sizeof(c)-1);
   }
-  tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason));
-  tt_str_op("another.example.com", ==, bcell.address);
-  tt_int_op(0x1020304, ==, bcell.flags);
-  tt_int_op(443, ==, bcell.port);
-  tt_int_op(5, ==, bcell.stream_id);
-  tt_int_op(0, ==, bcell.is_begindir);
+  tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_str_op("another.example.com", OP_EQ, bcell.address);
+  tt_int_op(0x1020304, OP_EQ, bcell.flags);
+  tt_int_op(443, OP_EQ, bcell.port);
+  tt_int_op(5, OP_EQ, bcell.stream_id);
+  tt_int_op(0, OP_EQ, bcell.is_begindir);
   tor_free(bcell.address);
 
   /* a begin cell with flags and even more cruft after that. */
@@ -173,12 +173,12 @@ test_cfmt_begin_cells(void *arg)
     const char c[] = "a-further.example.com:22\x00\xee\xaa\x00\xffHi mom";
     make_relay_cell(&cell, RELAY_COMMAND_BEGIN, c, sizeof(c)-1);
   }
-  tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason));
-  tt_str_op("a-further.example.com", ==, bcell.address);
-  tt_int_op(0xeeaa00ff, ==, bcell.flags);
-  tt_int_op(22, ==, bcell.port);
-  tt_int_op(5, ==, bcell.stream_id);
-  tt_int_op(0, ==, bcell.is_begindir);
+  tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_str_op("a-further.example.com", OP_EQ, bcell.address);
+  tt_int_op(0xeeaa00ff, OP_EQ, bcell.flags);
+  tt_int_op(22, OP_EQ, bcell.port);
+  tt_int_op(5, OP_EQ, bcell.stream_id);
+  tt_int_op(0, OP_EQ, bcell.is_begindir);
   tor_free(bcell.address);
 
   /* bad begin cell: impossible length. */
@@ -189,42 +189,42 @@ test_cfmt_begin_cells(void *arg)
   {
     relay_header_t rh;
     relay_header_unpack(&rh, cell.payload);
-    tt_int_op(rh.length, ==, 510);
+    tt_int_op(rh.length, OP_EQ, 510);
   }
-  tt_int_op(-2, ==, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_int_op(-2, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
 
   /* Bad begin cell: no body. */
   memset(&bcell, 0x7f, sizeof(bcell));
   make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "", 0);
-  tt_int_op(-1, ==, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_int_op(-1, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
 
   /* bad begin cell: no body. */
   memset(&bcell, 0x7f, sizeof(bcell));
   make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "", 0);
-  tt_int_op(-1, ==, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_int_op(-1, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
 
   /* bad begin cell: no colon */
   memset(&bcell, 0x7f, sizeof(bcell));
   make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "a.b", 4);
-  tt_int_op(-1, ==, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_int_op(-1, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
 
   /* bad begin cell: no ports */
   memset(&bcell, 0x7f, sizeof(bcell));
   make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "a.b:", 5);
-  tt_int_op(-1, ==, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_int_op(-1, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
 
   /* bad begin cell: bad port */
   memset(&bcell, 0x7f, sizeof(bcell));
   make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "a.b:xyz", 8);
-  tt_int_op(-1, ==, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_int_op(-1, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
   memset(&bcell, 0x7f, sizeof(bcell));
   make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "a.b:100000", 11);
-  tt_int_op(-1, ==, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_int_op(-1, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
 
   /* bad begin cell: no nul */
   memset(&bcell, 0x7f, sizeof(bcell));
   make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "a.b:80", 6);
-  tt_int_op(-1, ==, begin_cell_parse(&cell, &bcell, &end_reason));
+  tt_int_op(-1, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));
 
  done:
   tor_free(bcell.address);
@@ -244,47 +244,47 @@ test_cfmt_connected_cells(void *arg)
   make_relay_cell(&cell, RELAY_COMMAND_CONNECTED, "", 0);
   relay_header_unpack(&rh, cell.payload);
   r = connected_cell_parse(&rh, &cell, &addr, &ttl);
-  tt_int_op(r, ==, 0);
-  tt_int_op(tor_addr_family(&addr), ==, AF_UNSPEC);
-  tt_int_op(ttl, ==, -1);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(tor_addr_family(&addr), OP_EQ, AF_UNSPEC);
+  tt_int_op(ttl, OP_EQ, -1);
 
   /* A slightly less oldschool one: only an IPv4 address */
   make_relay_cell(&cell, RELAY_COMMAND_CONNECTED, "\x20\x30\x40\x50", 4);
   relay_header_unpack(&rh, cell.payload);
   r = connected_cell_parse(&rh, &cell, &addr, &ttl);
-  tt_int_op(r, ==, 0);
-  tt_int_op(tor_addr_family(&addr), ==, AF_INET);
-  tt_str_op(fmt_addr(&addr), ==, "32.48.64.80");
-  tt_int_op(ttl, ==, -1);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(tor_addr_family(&addr), OP_EQ, AF_INET);
+  tt_str_op(fmt_addr(&addr), OP_EQ, "32.48.64.80");
+  tt_int_op(ttl, OP_EQ, -1);
 
   /* Bogus but understandable: truncated TTL */
   make_relay_cell(&cell, RELAY_COMMAND_CONNECTED, "\x11\x12\x13\x14\x15", 5);
   relay_header_unpack(&rh, cell.payload);
   r = connected_cell_parse(&rh, &cell, &addr, &ttl);
-  tt_int_op(r, ==, 0);
-  tt_int_op(tor_addr_family(&addr), ==, AF_INET);
-  tt_str_op(fmt_addr(&addr), ==, "17.18.19.20");
-  tt_int_op(ttl, ==, -1);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(tor_addr_family(&addr), OP_EQ, AF_INET);
+  tt_str_op(fmt_addr(&addr), OP_EQ, "17.18.19.20");
+  tt_int_op(ttl, OP_EQ, -1);
 
   /* Regular IPv4 one: address and TTL */
   make_relay_cell(&cell, RELAY_COMMAND_CONNECTED,
                   "\x02\x03\x04\x05\x00\x00\x0e\x10", 8);
   relay_header_unpack(&rh, cell.payload);
   r = connected_cell_parse(&rh, &cell, &addr, &ttl);
-  tt_int_op(r, ==, 0);
-  tt_int_op(tor_addr_family(&addr), ==, AF_INET);
-  tt_str_op(fmt_addr(&addr), ==, "2.3.4.5");
-  tt_int_op(ttl, ==, 3600);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(tor_addr_family(&addr), OP_EQ, AF_INET);
+  tt_str_op(fmt_addr(&addr), OP_EQ, "2.3.4.5");
+  tt_int_op(ttl, OP_EQ, 3600);
 
   /* IPv4 with too-big TTL */
   make_relay_cell(&cell, RELAY_COMMAND_CONNECTED,
                   "\x02\x03\x04\x05\xf0\x00\x00\x00", 8);
   relay_header_unpack(&rh, cell.payload);
   r = connected_cell_parse(&rh, &cell, &addr, &ttl);
-  tt_int_op(r, ==, 0);
-  tt_int_op(tor_addr_family(&addr), ==, AF_INET);
-  tt_str_op(fmt_addr(&addr), ==, "2.3.4.5");
-  tt_int_op(ttl, ==, -1);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(tor_addr_family(&addr), OP_EQ, AF_INET);
+  tt_str_op(fmt_addr(&addr), OP_EQ, "2.3.4.5");
+  tt_int_op(ttl, OP_EQ, -1);
 
   /* IPv6 (ttl is mandatory) */
   make_relay_cell(&cell, RELAY_COMMAND_CONNECTED,
@@ -294,10 +294,10 @@ test_cfmt_connected_cells(void *arg)
                   "\x00\x00\x02\x58", 25);
   relay_header_unpack(&rh, cell.payload);
   r = connected_cell_parse(&rh, &cell, &addr, &ttl);
-  tt_int_op(r, ==, 0);
-  tt_int_op(tor_addr_family(&addr), ==, AF_INET6);
-  tt_str_op(fmt_addr(&addr), ==, "2607:f8b0:400c:c02::68");
-  tt_int_op(ttl, ==, 600);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(tor_addr_family(&addr), OP_EQ, AF_INET6);
+  tt_str_op(fmt_addr(&addr), OP_EQ, "2607:f8b0:400c:c02::68");
+  tt_int_op(ttl, OP_EQ, 600);
 
   /* IPv6 (ttl too big) */
   make_relay_cell(&cell, RELAY_COMMAND_CONNECTED,
@@ -307,17 +307,17 @@ test_cfmt_connected_cells(void *arg)
                   "\x90\x00\x02\x58", 25);
   relay_header_unpack(&rh, cell.payload);
   r = connected_cell_parse(&rh, &cell, &addr, &ttl);
-  tt_int_op(r, ==, 0);
-  tt_int_op(tor_addr_family(&addr), ==, AF_INET6);
-  tt_str_op(fmt_addr(&addr), ==, "2607:f8b0:400c:c02::68");
-  tt_int_op(ttl, ==, -1);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(tor_addr_family(&addr), OP_EQ, AF_INET6);
+  tt_str_op(fmt_addr(&addr), OP_EQ, "2607:f8b0:400c:c02::68");
+  tt_int_op(ttl, OP_EQ, -1);
 
   /* Bogus size: 3. */
   make_relay_cell(&cell, RELAY_COMMAND_CONNECTED,
                   "\x00\x01\x02", 3);
   relay_header_unpack(&rh, cell.payload);
   r = connected_cell_parse(&rh, &cell, &addr, &ttl);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
 
   /* Bogus family: 7. */
   make_relay_cell(&cell, RELAY_COMMAND_CONNECTED,
@@ -327,7 +327,7 @@ test_cfmt_connected_cells(void *arg)
                   "\x90\x00\x02\x58", 25);
   relay_header_unpack(&rh, cell.payload);
   r = connected_cell_parse(&rh, &cell, &addr, &ttl);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
 
   /* Truncated IPv6. */
   make_relay_cell(&cell, RELAY_COMMAND_CONNECTED,
@@ -337,7 +337,7 @@ test_cfmt_connected_cells(void *arg)
                   "\x00\x00\x02", 24);
   relay_header_unpack(&rh, cell.payload);
   r = connected_cell_parse(&rh, &cell, &addr, &ttl);
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
 
   /* Now make sure we can generate connected cells correctly. */
   /* Try an IPv4 address */
@@ -346,16 +346,16 @@ test_cfmt_connected_cells(void *arg)
   tor_addr_parse(&addr, "30.40.50.60");
   rh.length = connected_cell_format_payload(cell.payload+RELAY_HEADER_SIZE,
                                             &addr, 128);
-  tt_int_op(rh.length, ==, 8);
+  tt_int_op(rh.length, OP_EQ, 8);
   test_memeq_hex(cell.payload+RELAY_HEADER_SIZE, "1e28323c" "00000080");
 
   /* Try parsing it. */
   tor_addr_make_unspec(&addr);
   r = connected_cell_parse(&rh, &cell, &addr, &ttl);
-  tt_int_op(r, ==, 0);
-  tt_int_op(tor_addr_family(&addr), ==, AF_INET);
-  tt_str_op(fmt_addr(&addr), ==, "30.40.50.60");
-  tt_int_op(ttl, ==, 128);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(tor_addr_family(&addr), OP_EQ, AF_INET);
+  tt_str_op(fmt_addr(&addr), OP_EQ, "30.40.50.60");
+  tt_int_op(ttl, OP_EQ, 128);
 
   /* Try an IPv6 address */
   memset(&rh, 0, sizeof(rh));
@@ -363,7 +363,7 @@ test_cfmt_connected_cells(void *arg)
   tor_addr_parse(&addr, "2620::6b0:b:1a1a:0:26e5:480e");
   rh.length = connected_cell_format_payload(cell.payload+RELAY_HEADER_SIZE,
                                             &addr, 3600);
-  tt_int_op(rh.length, ==, 25);
+  tt_int_op(rh.length, OP_EQ, 25);
   test_memeq_hex(cell.payload + RELAY_HEADER_SIZE,
                  "00000000" "06"
                  "2620000006b0000b1a1a000026e5480e" "00000e10");
@@ -371,10 +371,10 @@ test_cfmt_connected_cells(void *arg)
   /* Try parsing it. */
   tor_addr_make_unspec(&addr);
   r = connected_cell_parse(&rh, &cell, &addr, &ttl);
-  tt_int_op(r, ==, 0);
-  tt_int_op(tor_addr_family(&addr), ==, AF_INET6);
-  tt_str_op(fmt_addr(&addr), ==, "2620:0:6b0:b:1a1a:0:26e5:480e");
-  tt_int_op(ttl, ==, 3600);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(tor_addr_family(&addr), OP_EQ, AF_INET6);
+  tt_str_op(fmt_addr(&addr), OP_EQ, "2620:0:6b0:b:1a1a:0:26e5:480e");
+  tt_int_op(ttl, OP_EQ, 3600);
 
  done:
   tor_free(mem_op_hex_tmp);
@@ -398,14 +398,14 @@ test_cfmt_create_cells(void *arg)
   crypto_rand((char*)b, TAP_ONIONSKIN_CHALLENGE_LEN);
   cell.command = CELL_CREATE;
   memcpy(cell.payload, b, TAP_ONIONSKIN_CHALLENGE_LEN);
-  tt_int_op(0, ==, create_cell_parse(&cc, &cell));
-  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);
-  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);
-  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_int_op(0, OP_EQ, create_cell_parse(&cc, &cell));
+  tt_int_op(CELL_CREATE, OP_EQ, cc.cell_type);
+  tt_int_op(ONION_HANDSHAKE_TYPE_TAP, OP_EQ, cc.handshake_type);
+  tt_int_op(TAP_ONIONSKIN_CHALLENGE_LEN, OP_EQ, cc.handshake_len);
+  tt_mem_op(cc.onionskin,OP_EQ, b, TAP_ONIONSKIN_CHALLENGE_LEN + 10);
+  tt_int_op(0, OP_EQ, create_cell_format(&cell2, &cc));
+  tt_int_op(cell.command, OP_EQ, cell2.command);
+  tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);
 
   /* A valid create_fast cell. */
   memset(&cell, 0, sizeof(cell));
@@ -413,14 +413,14 @@ test_cfmt_create_cells(void *arg)
   crypto_rand((char*)b, CREATE_FAST_LEN);
   cell.command = CELL_CREATE_FAST;
   memcpy(cell.payload, b, CREATE_FAST_LEN);
-  tt_int_op(0, ==, create_cell_parse(&cc, &cell));
-  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);
-  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);
-  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_int_op(0, OP_EQ, create_cell_parse(&cc, &cell));
+  tt_int_op(CELL_CREATE_FAST, OP_EQ, cc.cell_type);
+  tt_int_op(ONION_HANDSHAKE_TYPE_FAST, OP_EQ, cc.handshake_type);
+  tt_int_op(CREATE_FAST_LEN, OP_EQ, cc.handshake_len);
+  tt_mem_op(cc.onionskin,OP_EQ, b, CREATE_FAST_LEN + 10);
+  tt_int_op(0, OP_EQ, create_cell_format(&cell2, &cc));
+  tt_int_op(cell.command, OP_EQ, cell2.command);
+  tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);
 
   /* A valid create2 cell with a TAP payload */
   memset(&cell, 0, sizeof(cell));
@@ -429,14 +429,14 @@ test_cfmt_create_cells(void *arg)
   cell.command = CELL_CREATE2;
   memcpy(cell.payload, "\x00\x00\x00\xBA", 4); /* TAP, 186 bytes long */
   memcpy(cell.payload+4, b, TAP_ONIONSKIN_CHALLENGE_LEN);
-  tt_int_op(0, ==, create_cell_parse(&cc, &cell));
-  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);
-  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);
-  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_int_op(0, OP_EQ, create_cell_parse(&cc, &cell));
+  tt_int_op(CELL_CREATE2, OP_EQ, cc.cell_type);
+  tt_int_op(ONION_HANDSHAKE_TYPE_TAP, OP_EQ, cc.handshake_type);
+  tt_int_op(TAP_ONIONSKIN_CHALLENGE_LEN, OP_EQ, cc.handshake_len);
+  tt_mem_op(cc.onionskin,OP_EQ, b, TAP_ONIONSKIN_CHALLENGE_LEN + 10);
+  tt_int_op(0, OP_EQ, create_cell_format(&cell2, &cc));
+  tt_int_op(cell.command, OP_EQ, cell2.command);
+  tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);
 
   /* A valid create2 cell with an ntor payload */
   memset(&cell, 0, sizeof(cell));
@@ -445,14 +445,14 @@ test_cfmt_create_cells(void *arg)
   cell.command = CELL_CREATE2;
   memcpy(cell.payload, "\x00\x02\x00\x54", 4); /* ntor, 84 bytes long */
   memcpy(cell.payload+4, b, NTOR_ONIONSKIN_LEN);
-  tt_int_op(0, ==, create_cell_parse(&cc, &cell));
-  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);
-  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);
-  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_int_op(0, OP_EQ, create_cell_parse(&cc, &cell));
+  tt_int_op(CELL_CREATE2, OP_EQ, cc.cell_type);
+  tt_int_op(ONION_HANDSHAKE_TYPE_NTOR, OP_EQ, cc.handshake_type);
+  tt_int_op(NTOR_ONIONSKIN_LEN, OP_EQ, cc.handshake_len);
+  tt_mem_op(cc.onionskin,OP_EQ, b, NTOR_ONIONSKIN_LEN + 10);
+  tt_int_op(0, OP_EQ, create_cell_format(&cell2, &cc));
+  tt_int_op(cell.command, OP_EQ, cell2.command);
+  tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);
 
   /* A valid create cell with an ntor payload, in legacy format. */
   memset(&cell, 0, sizeof(cell));
@@ -461,38 +461,38 @@ test_cfmt_create_cells(void *arg)
   cell.command = CELL_CREATE;
   memcpy(cell.payload, "ntorNTORntorNTOR", 16);
   memcpy(cell.payload+16, b, NTOR_ONIONSKIN_LEN);
-  tt_int_op(0, ==, create_cell_parse(&cc, &cell));
-  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);
-  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);
-  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_int_op(0, OP_EQ, create_cell_parse(&cc, &cell));
+  tt_int_op(CELL_CREATE, OP_EQ, cc.cell_type);
+  tt_int_op(ONION_HANDSHAKE_TYPE_NTOR, OP_EQ, cc.handshake_type);
+  tt_int_op(NTOR_ONIONSKIN_LEN, OP_EQ, cc.handshake_len);
+  tt_mem_op(cc.onionskin,OP_EQ, b, NTOR_ONIONSKIN_LEN + 10);
+  tt_int_op(0, OP_EQ, create_cell_format(&cell2, &cc));
+  tt_int_op(cell.command, OP_EQ, cell2.command);
+  tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);
 
   /* == Okay, now let's try to parse some impossible stuff. */
 
   /* It has to be some kind of a create cell! */
   cell.command = CELL_CREATED;
-  tt_int_op(-1, ==, create_cell_parse(&cc, &cell));
+  tt_int_op(-1, OP_EQ, create_cell_parse(&cc, &cell));
 
   /* You can't acutally make an unparseable CREATE or CREATE_FAST cell. */
 
   /* Try some CREATE2 cells.  First with a bad type. */
   cell.command = CELL_CREATE2;
   memcpy(cell.payload, "\x00\x50\x00\x99", 4); /* Type 0x50???? */
-  tt_int_op(-1, ==, create_cell_parse(&cc, &cell));
+  tt_int_op(-1, OP_EQ, create_cell_parse(&cc, &cell));
   /* Now a good type with an incorrect length. */
   memcpy(cell.payload, "\x00\x00\x00\xBC", 4); /* TAP, 187 bytes.*/
-  tt_int_op(-1, ==, create_cell_parse(&cc, &cell));
+  tt_int_op(-1, OP_EQ, create_cell_parse(&cc, &cell));
   /* Now a good type with a ridiculous length. */
   memcpy(cell.payload, "\x00\x00\x02\x00", 4); /* TAP, 512 bytes.*/
-  tt_int_op(-1, ==, create_cell_parse(&cc, &cell));
+  tt_int_op(-1, OP_EQ, create_cell_parse(&cc, &cell));
 
   /* == Time to try formatting bad cells.  The important thing is that
      we reject big lengths, so just check that for now. */
   cc.handshake_len = 512;
-  tt_int_op(-1, ==, create_cell_format(&cell2, &cc));
+  tt_int_op(-1, OP_EQ, create_cell_format(&cell2, &cc));
 
   /* == Try formatting a create2 cell we don't understand. XXXX */
 
@@ -516,13 +516,13 @@ test_cfmt_created_cells(void *arg)
   crypto_rand((char*)b, TAP_ONIONSKIN_REPLY_LEN);
   cell.command = CELL_CREATED;
   memcpy(cell.payload, b, TAP_ONIONSKIN_REPLY_LEN);
-  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);
-  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);
-  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_int_op(0, OP_EQ, created_cell_parse(&cc, &cell));
+  tt_int_op(CELL_CREATED, OP_EQ, cc.cell_type);
+  tt_int_op(TAP_ONIONSKIN_REPLY_LEN, OP_EQ, cc.handshake_len);
+  tt_mem_op(cc.reply,OP_EQ, b, TAP_ONIONSKIN_REPLY_LEN + 10);
+  tt_int_op(0, OP_EQ, created_cell_format(&cell2, &cc));
+  tt_int_op(cell.command, OP_EQ, cell2.command);
+  tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);
 
   /* A good CREATED_FAST cell */
   memset(&cell, 0, sizeof(cell));
@@ -530,13 +530,13 @@ test_cfmt_created_cells(void *arg)
   crypto_rand((char*)b, CREATED_FAST_LEN);
   cell.command = CELL_CREATED_FAST;
   memcpy(cell.payload, b, CREATED_FAST_LEN);
-  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);
-  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);
-  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_int_op(0, OP_EQ, created_cell_parse(&cc, &cell));
+  tt_int_op(CELL_CREATED_FAST, OP_EQ, cc.cell_type);
+  tt_int_op(CREATED_FAST_LEN, OP_EQ, cc.handshake_len);
+  tt_mem_op(cc.reply,OP_EQ, b, CREATED_FAST_LEN + 10);
+  tt_int_op(0, OP_EQ, created_cell_format(&cell2, &cc));
+  tt_int_op(cell.command, OP_EQ, cell2.command);
+  tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);
 
   /* A good CREATED2 cell with short reply */
   memset(&cell, 0, sizeof(cell));
@@ -545,13 +545,13 @@ test_cfmt_created_cells(void *arg)
   cell.command = CELL_CREATED2;
   memcpy(cell.payload, "\x00\x40", 2);
   memcpy(cell.payload+2, b, 64);
-  tt_int_op(0, ==, created_cell_parse(&cc, &cell));
-  tt_int_op(CELL_CREATED2, ==, cc.cell_type);
-  tt_int_op(64, ==, cc.handshake_len);
-  tt_mem_op(cc.reply,==, b, 80);
-  tt_int_op(0, ==, created_cell_format(&cell2, &cc));
-  tt_int_op(cell.command, ==, cell2.command);
-  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_int_op(0, OP_EQ, created_cell_parse(&cc, &cell));
+  tt_int_op(CELL_CREATED2, OP_EQ, cc.cell_type);
+  tt_int_op(64, OP_EQ, cc.handshake_len);
+  tt_mem_op(cc.reply,OP_EQ, b, 80);
+  tt_int_op(0, OP_EQ, created_cell_format(&cell2, &cc));
+  tt_int_op(cell.command, OP_EQ, cell2.command);
+  tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);
 
   /* A good CREATED2 cell with maximal reply */
   memset(&cell, 0, sizeof(cell));
@@ -560,13 +560,13 @@ test_cfmt_created_cells(void *arg)
   cell.command = CELL_CREATED2;
   memcpy(cell.payload, "\x01\xF0", 2);
   memcpy(cell.payload+2, b, 496);
-  tt_int_op(0, ==, created_cell_parse(&cc, &cell));
-  tt_int_op(CELL_CREATED2, ==, cc.cell_type);
-  tt_int_op(496, ==, cc.handshake_len);
-  tt_mem_op(cc.reply,==, b, 496);
-  tt_int_op(0, ==, created_cell_format(&cell2, &cc));
-  tt_int_op(cell.command, ==, cell2.command);
-  tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE);
+  tt_int_op(0, OP_EQ, created_cell_parse(&cc, &cell));
+  tt_int_op(CELL_CREATED2, OP_EQ, cc.cell_type);
+  tt_int_op(496, OP_EQ, cc.handshake_len);
+  tt_mem_op(cc.reply,OP_EQ, b, 496);
+  tt_int_op(0, OP_EQ, created_cell_format(&cell2, &cc));
+  tt_int_op(cell.command, OP_EQ, cell2.command);
+  tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);
 
   /* Bogus CREATED2 cell: too long! */
   memset(&cell, 0, sizeof(cell));
@@ -574,11 +574,11 @@ test_cfmt_created_cells(void *arg)
   crypto_rand((char*)b, 496);
   cell.command = CELL_CREATED2;
   memcpy(cell.payload, "\x01\xF1", 2);
-  tt_int_op(-1, ==, created_cell_parse(&cc, &cell));
+  tt_int_op(-1, OP_EQ, created_cell_parse(&cc, &cell));
 
   /* Unformattable CREATED2 cell: too long! */
   cc.handshake_len = 497;
-  tt_int_op(-1, ==, created_cell_format(&cell2, &cc));
+  tt_int_op(-1, OP_EQ, created_cell_format(&cell2, &cc));
 
  done:
   ;
@@ -606,21 +606,21 @@ test_cfmt_extend_cells(void *arg)
   memcpy(p, "\x12\xf4\x00\x01\x01\x02", 6); /* 18 244 0 1 : 258 */
   memcpy(p+6,b,TAP_ONIONSKIN_CHALLENGE_LEN);
   memcpy(p+6+TAP_ONIONSKIN_CHALLENGE_LEN, "electroencephalogram", 20);
-  tt_int_op(0, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND,
+  tt_int_op(0, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND,
                                      p, 26+TAP_ONIONSKIN_CHALLENGE_LEN));
-  tt_int_op(RELAY_COMMAND_EXTEND, ==, ec.cell_type);
-  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));
-  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);
-  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);
-  tt_mem_op(p2,==, p, RELAY_PAYLOAD_SIZE);
+  tt_int_op(RELAY_COMMAND_EXTEND, OP_EQ, ec.cell_type);
+  tt_str_op("18.244.0.1", OP_EQ, fmt_addr(&ec.orport_ipv4.addr));
+  tt_int_op(258, OP_EQ, ec.orport_ipv4.port);
+  tt_int_op(AF_UNSPEC, OP_EQ, tor_addr_family(&ec.orport_ipv6.addr));
+  tt_mem_op(ec.node_id,OP_EQ, "electroencephalogram", 20);
+  tt_int_op(cc->cell_type, OP_EQ, CELL_CREATE);
+  tt_int_op(cc->handshake_type, OP_EQ, ONION_HANDSHAKE_TYPE_TAP);
+  tt_int_op(cc->handshake_len, OP_EQ, TAP_ONIONSKIN_CHALLENGE_LEN);
+  tt_mem_op(cc->onionskin,OP_EQ, b, TAP_ONIONSKIN_CHALLENGE_LEN+20);
+  tt_int_op(0, OP_EQ, extend_cell_format(&p2_cmd, &p2_len, p2, &ec));
+  tt_int_op(p2_cmd, OP_EQ, RELAY_COMMAND_EXTEND);
+  tt_int_op(p2_len, OP_EQ, 26+TAP_ONIONSKIN_CHALLENGE_LEN);
+  tt_mem_op(p2,OP_EQ, p, RELAY_PAYLOAD_SIZE);
 
   /* Let's do an ntor stuffed in a legacy EXTEND cell */
   memset(p, 0, sizeof(p));
@@ -630,22 +630,22 @@ test_cfmt_extend_cells(void *arg)
   memcpy(p+6,"ntorNTORntorNTOR", 16);
   memcpy(p+22, b, NTOR_ONIONSKIN_LEN);
   memcpy(p+6+TAP_ONIONSKIN_CHALLENGE_LEN, "electroencephalogram", 20);
-  tt_int_op(0, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND,
+  tt_int_op(0, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND,
                                      p, 26+TAP_ONIONSKIN_CHALLENGE_LEN));
-  tt_int_op(RELAY_COMMAND_EXTEND, ==, ec.cell_type);
-  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));
-  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);
-  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);
-  tt_mem_op(p2,==, p, RELAY_PAYLOAD_SIZE);
-  tt_int_op(0, ==, create_cell_format_relayed(&cell, cc));
+  tt_int_op(RELAY_COMMAND_EXTEND, OP_EQ, ec.cell_type);
+  tt_str_op("18.244.0.1", OP_EQ, fmt_addr(&ec.orport_ipv4.addr));
+  tt_int_op(258, OP_EQ, ec.orport_ipv4.port);
+  tt_int_op(AF_UNSPEC, OP_EQ, tor_addr_family(&ec.orport_ipv6.addr));
+  tt_mem_op(ec.node_id,OP_EQ, "electroencephalogram", 20);
+  tt_int_op(cc->cell_type, OP_EQ, CELL_CREATE2);
+  tt_int_op(cc->handshake_type, OP_EQ, ONION_HANDSHAKE_TYPE_NTOR);
+  tt_int_op(cc->handshake_len, OP_EQ, NTOR_ONIONSKIN_LEN);
+  tt_mem_op(cc->onionskin,OP_EQ, b, NTOR_ONIONSKIN_LEN+20);
+  tt_int_op(0, OP_EQ, extend_cell_format(&p2_cmd, &p2_len, p2, &ec));
+  tt_int_op(p2_cmd, OP_EQ, RELAY_COMMAND_EXTEND);
+  tt_int_op(p2_len, OP_EQ, 26+TAP_ONIONSKIN_CHALLENGE_LEN);
+  tt_mem_op(p2,OP_EQ, p, RELAY_PAYLOAD_SIZE);
+  tt_int_op(0, OP_EQ, create_cell_format_relayed(&cell, cc));
 
   /* Now let's do a minimal ntor EXTEND2 cell. */
   memset(&ec, 0xff, sizeof(ec));
@@ -659,21 +659,21 @@ test_cfmt_extend_cells(void *arg)
   /* Prep for the handshake: type and length */
   memcpy(p+31, "\x00\x02\x00\x54", 4);
   memcpy(p+35, b, NTOR_ONIONSKIN_LEN);
-  tt_int_op(0, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
+  tt_int_op(0, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
                                      p, 35+NTOR_ONIONSKIN_LEN));
-  tt_int_op(RELAY_COMMAND_EXTEND2, ==, ec.cell_type);
-  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));
-  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);
-  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);
-  tt_mem_op(p2,==, p, RELAY_PAYLOAD_SIZE);
+  tt_int_op(RELAY_COMMAND_EXTEND2, OP_EQ, ec.cell_type);
+  tt_str_op("18.244.0.1", OP_EQ, fmt_addr(&ec.orport_ipv4.addr));
+  tt_int_op(61681, OP_EQ, ec.orport_ipv4.port);
+  tt_int_op(AF_UNSPEC, OP_EQ, tor_addr_family(&ec.orport_ipv6.addr));
+  tt_mem_op(ec.node_id,OP_EQ, "anarchoindividualist", 20);
+  tt_int_op(cc->cell_type, OP_EQ, CELL_CREATE2);
+  tt_int_op(cc->handshake_type, OP_EQ, ONION_HANDSHAKE_TYPE_NTOR);
+  tt_int_op(cc->handshake_len, OP_EQ, NTOR_ONIONSKIN_LEN);
+  tt_mem_op(cc->onionskin,OP_EQ, b, NTOR_ONIONSKIN_LEN+20);
+  tt_int_op(0, OP_EQ, extend_cell_format(&p2_cmd, &p2_len, p2, &ec));
+  tt_int_op(p2_cmd, OP_EQ, RELAY_COMMAND_EXTEND2);
+  tt_int_op(p2_len, OP_EQ, 35+NTOR_ONIONSKIN_LEN);
+  tt_mem_op(p2,OP_EQ, p, RELAY_PAYLOAD_SIZE);
 
   /* Now let's do a fanciful EXTEND2 cell. */
   memset(&ec, 0xff, sizeof(ec));
@@ -692,21 +692,21 @@ test_cfmt_extend_cells(void *arg)
   /* Prep for the handshake: weird type and length */
   memcpy(p+85, "\x01\x05\x00\x63", 4);
   memcpy(p+89, b, 99);
-  tt_int_op(0, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, p, 89+99));
-  tt_int_op(RELAY_COMMAND_EXTEND2, ==, ec.cell_type);
-  tt_str_op("18.244.0.1", ==, fmt_addr(&ec.orport_ipv4.addr));
-  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);
-  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);
-  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);
+  tt_int_op(0, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, p, 89+99));
+  tt_int_op(RELAY_COMMAND_EXTEND2, OP_EQ, ec.cell_type);
+  tt_str_op("18.244.0.1", OP_EQ, fmt_addr(&ec.orport_ipv4.addr));
+  tt_int_op(61681, OP_EQ, ec.orport_ipv4.port);
+  tt_str_op("2002::f0:c51e", OP_EQ, fmt_addr(&ec.orport_ipv6.addr));
+  tt_int_op(4370, OP_EQ, ec.orport_ipv6.port);
+  tt_mem_op(ec.node_id,OP_EQ, "anthropomorphization", 20);
+  tt_int_op(cc->cell_type, OP_EQ, CELL_CREATE2);
+  tt_int_op(cc->handshake_type, OP_EQ, 0x105);
+  tt_int_op(cc->handshake_len, OP_EQ, 99);
+  tt_mem_op(cc->onionskin,OP_EQ, b, 99+20);
+  tt_int_op(0, OP_EQ, extend_cell_format(&p2_cmd, &p2_len, p2, &ec));
+  tt_int_op(p2_cmd, OP_EQ, RELAY_COMMAND_EXTEND2);
   /* We'll generate it minus the IPv6 address and minus the konami code */
-  tt_int_op(p2_len, ==, 89+99-34-20);
+  tt_int_op(p2_len, OP_EQ, 89+99-34-20);
   test_memeq_hex(p2,
                  /* Two items: one that same darn IP address. */
                  "02000612F40001F0F1"
@@ -714,8 +714,8 @@ test_cfmt_extend_cells(void *arg)
                  "0214616e7468726f706f6d6f727068697a6174696f6e"
                  /* Now the handshake prologue */
                  "01050063");
-  tt_mem_op(p2+1+8+22+4,==, b, 99+20);
-  tt_int_op(0, ==, create_cell_format_relayed(&cell, cc));
+  tt_mem_op(p2+1+8+22+4,OP_EQ, b, 99+20);
+  tt_int_op(0, OP_EQ, create_cell_format_relayed(&cell, cc));
 
   /* == Now try parsing some junk */
 
@@ -724,7 +724,7 @@ test_cfmt_extend_cells(void *arg)
   memcpy(p, "\x02\x00\x06\x12\xf4\x00\x01\xf0\xf1", 9);
   memcpy(p+9, "\x02\x14" "anarchoindividualist", 22);
   memcpy(p+31, "\xff\xff\x01\xd0", 4);
-  tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
+  tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
                                       p, sizeof(p)));
 
   /* Try two identities. */
@@ -733,14 +733,14 @@ test_cfmt_extend_cells(void *arg)
   memcpy(p+9, "\x02\x14" "anarchoindividualist", 22);
   memcpy(p+31, "\x02\x14" "autodepolymerization", 22);
   memcpy(p+53, "\xff\xff\x00\x10", 4);
-  tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
+  tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
                                       p, sizeof(p)));
 
   /* No identities. */
   memset(p, 0, sizeof(p));
   memcpy(p, "\x01\x00\x06\x12\xf4\x00\x01\xf0\xf1", 9);
   memcpy(p+53, "\xff\xff\x00\x10", 4);
-  tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
+  tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
                                       p, sizeof(p)));
 
   /* Try a bad IPv4 address (too long, too short)*/
@@ -748,13 +748,13 @@ test_cfmt_extend_cells(void *arg)
   memcpy(p, "\x02\x00\x07\x12\xf4\x00\x01\xf0\xf1\xff", 10);
   memcpy(p+10, "\x02\x14" "anarchoindividualist", 22);
   memcpy(p+32, "\xff\xff\x00\x10", 4);
-  tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
+  tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
                                       p, sizeof(p)));
   memset(p, 0, sizeof(p));
   memcpy(p, "\x02\x00\x05\x12\xf4\x00\x01\xf0", 8);
   memcpy(p+8, "\x02\x14" "anarchoindividualist", 22);
   memcpy(p+30, "\xff\xff\x00\x10", 4);
-  tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
+  tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
                                       p, sizeof(p)));
 
   /* IPv6 address (too long, too short, no IPv4)*/
@@ -763,28 +763,28 @@ test_cfmt_extend_cells(void *arg)
   memcpy(p+9, "\x02\x14" "anarchoindividualist", 22);
   memcpy(p+31, "\x01\x13" "xxxxxxxxxxxxxxxxYYZ", 19);
   memcpy(p+50, "\xff\xff\x00\x20", 4);
-  tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
+  tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
                                       p, sizeof(p)));
   memset(p, 0, sizeof(p));
   memcpy(p, "\x03\x00\x06\x12\xf4\x00\x01\xf0\xf1", 9);
   memcpy(p+9, "\x02\x14" "anarchoindividualist", 22);
   memcpy(p+31, "\x01\x11" "xxxxxxxxxxxxxxxxY", 17);
   memcpy(p+48, "\xff\xff\x00\x20", 4);
-  tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
+  tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
                                       p, sizeof(p)));
   memset(p, 0, sizeof(p));
   memcpy(p, "\x02", 1);
   memcpy(p+1, "\x02\x14" "anarchoindividualist", 22);
   memcpy(p+23, "\x01\x12" "xxxxxxxxxxxxxxxxYY", 18);
   memcpy(p+41, "\xff\xff\x00\x20", 4);
-  tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
+  tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
                                       p, sizeof(p)));
 
   /* Running out of space in specifiers  */
   memset(p,0,sizeof(p));
   memcpy(p, "\x05\x0a\xff", 3);
   memcpy(p+3+255, "\x0a\xff", 2);
-  tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
+  tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2,
                                       p, sizeof(p)));
 
   /* Fuzz, because why not. */
@@ -823,16 +823,16 @@ test_cfmt_extended_cells(void *arg)
   memset(b, 0, sizeof(b));
   crypto_rand((char*)b, TAP_ONIONSKIN_REPLY_LEN);
   memcpy(p,b,TAP_ONIONSKIN_REPLY_LEN);
-  tt_int_op(0, ==, extended_cell_parse(&ec, RELAY_COMMAND_EXTENDED, p,
+  tt_int_op(0, OP_EQ, extended_cell_parse(&ec, RELAY_COMMAND_EXTENDED, p,
                                        TAP_ONIONSKIN_REPLY_LEN));
-  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);
-  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);
-  tt_mem_op(p2,==, p, sizeof(p2));
+  tt_int_op(RELAY_COMMAND_EXTENDED, OP_EQ, ec.cell_type);
+  tt_int_op(cc->cell_type, OP_EQ, CELL_CREATED);
+  tt_int_op(cc->handshake_len, OP_EQ, TAP_ONIONSKIN_REPLY_LEN);
+  tt_mem_op(cc->reply,OP_EQ, b, TAP_ONIONSKIN_REPLY_LEN);
+  tt_int_op(0, OP_EQ, extended_cell_format(&p2_cmd, &p2_len, p2, &ec));
+  tt_int_op(RELAY_COMMAND_EXTENDED, OP_EQ, p2_cmd);
+  tt_int_op(TAP_ONIONSKIN_REPLY_LEN, OP_EQ, p2_len);
+  tt_mem_op(p2,OP_EQ, p, sizeof(p2));
 
   /* Try an EXTENDED2 cell */
   memset(&ec, 0xff, sizeof(ec));
@@ -841,25 +841,25 @@ test_cfmt_extended_cells(void *arg)
   crypto_rand((char*)b, 42);
   memcpy(p,"\x00\x2a",2);
   memcpy(p+2,b,42);
-  tt_int_op(0, ==, extended_cell_parse(&ec, RELAY_COMMAND_EXTENDED2, p, 2+42));
-  tt_int_op(RELAY_COMMAND_EXTENDED2, ==, ec.cell_type);
-  tt_int_op(cc->cell_type, ==, CELL_CREATED2);
-  tt_int_op(cc->handshake_len, ==, 42);
-  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);
-  tt_mem_op(p2,==, p, sizeof(p2));
+  tt_int_op(0, OP_EQ, extended_cell_parse(&ec, RELAY_COMMAND_EXTENDED2, p, 2+42));
+  tt_int_op(RELAY_COMMAND_EXTENDED2, OP_EQ, ec.cell_type);
+  tt_int_op(cc->cell_type, OP_EQ, CELL_CREATED2);
+  tt_int_op(cc->handshake_len, OP_EQ, 42);
+  tt_mem_op(cc->reply,OP_EQ, b, 42+10);
+  tt_int_op(0, OP_EQ, extended_cell_format(&p2_cmd, &p2_len, p2, &ec));
+  tt_int_op(RELAY_COMMAND_EXTENDED2, OP_EQ, p2_cmd);
+  tt_int_op(2+42, OP_EQ, p2_len);
+  tt_mem_op(p2,OP_EQ, p, sizeof(p2));
 
   /* Try an almost-too-long EXTENDED2 cell */
   memcpy(p, "\x01\xf0", 2);
-  tt_int_op(0, ==,
+  tt_int_op(0, OP_EQ,
             extended_cell_parse(&ec, RELAY_COMMAND_EXTENDED2, p, sizeof(p)));
 
   /* Now try a too-long extended2 cell. That's the only misparse I can think
    * of. */
   memcpy(p, "\x01\xf1", 2);
-  tt_int_op(-1, ==,
+  tt_int_op(-1, OP_EQ,
             extended_cell_parse(&ec, RELAY_COMMAND_EXTENDED2, p, sizeof(p)));
 
  done:
@@ -903,22 +903,22 @@ test_cfmt_resolved_cells(void *arg)
   /* Let's try an empty cell */
   SET_CELL("");
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, 0);
-  tt_int_op(r, ==, 0);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(errcode, OP_EQ, 0);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
   CLEAR_ADDRS(); /* redundant but let's be consistent */
 
   /* Cell with one ipv4 addr */
   SET_CELL("\x04\x04" "\x7f\x00\x02\x0a" "\x00\00\x01\x00");
-  tt_int_op(rh.length, ==, 10);
+  tt_int_op(rh.length, OP_EQ, 10);
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, 0);
-  tt_int_op(r, ==, 0);
-  tt_int_op(smartlist_len(addrs), ==, 1);
+  tt_int_op(errcode, OP_EQ, 0);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 1);
   a = smartlist_get(addrs, 0);
-  tt_str_op(fmt_addr(&a->addr), ==, "127.0.2.10");
-  tt_ptr_op(a->hostname, ==, NULL);
-  tt_int_op(a->ttl, ==, 256);
+  tt_str_op(fmt_addr(&a->addr), OP_EQ, "127.0.2.10");
+  tt_ptr_op(a->hostname, OP_EQ, NULL);
+  tt_int_op(a->ttl, OP_EQ, 256);
   CLEAR_ADDRS();
 
   /* Cell with one ipv6 addr */
@@ -926,30 +926,30 @@ test_cfmt_resolved_cells(void *arg)
            "\x20\x02\x90\x90\x00\x00\x00\x00"
            "\x00\x00\x00\x00\xf0\xf0\xab\xcd"
            "\x02\00\x00\x01");
-  tt_int_op(rh.length, ==, 22);
+  tt_int_op(rh.length, OP_EQ, 22);
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, 0);
-  tt_int_op(r, ==, 0);
-  tt_int_op(smartlist_len(addrs), ==, 1);
+  tt_int_op(errcode, OP_EQ, 0);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 1);
   a = smartlist_get(addrs, 0);
-  tt_str_op(fmt_addr(&a->addr), ==, "2002:9090::f0f0:abcd");
-  tt_ptr_op(a->hostname, ==, NULL);
-  tt_int_op(a->ttl, ==, 0x2000001);
+  tt_str_op(fmt_addr(&a->addr), OP_EQ, "2002:9090::f0f0:abcd");
+  tt_ptr_op(a->hostname, OP_EQ, NULL);
+  tt_int_op(a->ttl, OP_EQ, 0x2000001);
   CLEAR_ADDRS();
 
   /* Cell with one hostname */
   SET_CELL("\x00\x11"
            "motherbrain.zebes"
            "\x00\00\x00\x00");
-  tt_int_op(rh.length, ==, 23);
+  tt_int_op(rh.length, OP_EQ, 23);
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, 0);
-  tt_int_op(r, ==, 0);
-  tt_int_op(smartlist_len(addrs), ==, 1);
+  tt_int_op(errcode, OP_EQ, 0);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 1);
   a = smartlist_get(addrs, 0);
   tt_assert(tor_addr_is_null(&a->addr));
-  tt_str_op(a->hostname, ==, "motherbrain.zebes");
-  tt_int_op(a->ttl, ==, 0);
+  tt_str_op(a->hostname, OP_EQ, "motherbrain.zebes");
+  tt_int_op(a->ttl, OP_EQ, 0);
   CLEAR_ADDRS();
 
 #define LONG_NAME \
@@ -958,51 +958,51 @@ test_cfmt_resolved_cells(void *arg)
   "function-is-already-very-full.of-copy-and-pasted-stuff.having-this-app" \
   "ear-more-than-once-would-bother-me-somehow.is"
 
-  tt_int_op(strlen(LONG_NAME), ==, 255);
+  tt_int_op(strlen(LONG_NAME), OP_EQ, 255);
   SET_CELL("\x00\xff"
            LONG_NAME
            "\x00\01\x00\x00");
-  tt_int_op(rh.length, ==, 261);
+  tt_int_op(rh.length, OP_EQ, 261);
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, 0);
-  tt_int_op(r, ==, 0);
-  tt_int_op(smartlist_len(addrs), ==, 1);
+  tt_int_op(errcode, OP_EQ, 0);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 1);
   a = smartlist_get(addrs, 0);
   tt_assert(tor_addr_is_null(&a->addr));
-  tt_str_op(a->hostname, ==, LONG_NAME);
-  tt_int_op(a->ttl, ==, 65536);
+  tt_str_op(a->hostname, OP_EQ, LONG_NAME);
+  tt_int_op(a->ttl, OP_EQ, 65536);
   CLEAR_ADDRS();
 
   /* Cells with an error */
   SET_CELL("\xf0\x2b"
            "I'm sorry, Dave. I'm afraid I can't do that"
            "\x00\x11\x22\x33");
-  tt_int_op(rh.length, ==, 49);
+  tt_int_op(rh.length, OP_EQ, 49);
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, RESOLVED_TYPE_ERROR_TRANSIENT);
-  tt_int_op(r, ==, 0);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(errcode, OP_EQ, RESOLVED_TYPE_ERROR_TRANSIENT);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
   CLEAR_ADDRS();
 
   SET_CELL("\xf1\x40"
            "This hostname is too important for me to allow you to resolve it"
            "\x00\x00\x00\x00");
-  tt_int_op(rh.length, ==, 70);
+  tt_int_op(rh.length, OP_EQ, 70);
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, RESOLVED_TYPE_ERROR);
-  tt_int_op(r, ==, 0);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(errcode, OP_EQ, RESOLVED_TYPE_ERROR);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
   CLEAR_ADDRS();
 
   /* Cell with an unrecognized type */
   SET_CELL("\xee\x16"
            "fault in the AE35 unit"
            "\x09\x09\x01\x01");
-  tt_int_op(rh.length, ==, 28);
+  tt_int_op(rh.length, OP_EQ, 28);
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, 0);
-  tt_int_op(r, ==, 0);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(errcode, OP_EQ, 0);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
   CLEAR_ADDRS();
 
   /* Cell with one of each */
@@ -1027,21 +1027,21 @@ test_cfmt_resolved_cells(void *arg)
            "\x00\00\x00\x00"
            );
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, 0); /* no error reported; we got answers */
-  tt_int_op(r, ==, 0);
-  tt_int_op(smartlist_len(addrs), ==, 3);
+  tt_int_op(errcode, OP_EQ, 0); /* no error reported; we got answers */
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 3);
   a = smartlist_get(addrs, 0);
-  tt_str_op(fmt_addr(&a->addr), ==, "2002:9090::f0f0:abcd");
-  tt_ptr_op(a->hostname, ==, NULL);
-  tt_int_op(a->ttl, ==, 0x2000001);
+  tt_str_op(fmt_addr(&a->addr), OP_EQ, "2002:9090::f0f0:abcd");
+  tt_ptr_op(a->hostname, OP_EQ, NULL);
+  tt_int_op(a->ttl, OP_EQ, 0x2000001);
   a = smartlist_get(addrs, 1);
-  tt_str_op(fmt_addr(&a->addr), ==, "127.0.2.10");
-  tt_ptr_op(a->hostname, ==, NULL);
-  tt_int_op(a->ttl, ==, 256);
+  tt_str_op(fmt_addr(&a->addr), OP_EQ, "127.0.2.10");
+  tt_ptr_op(a->hostname, OP_EQ, NULL);
+  tt_int_op(a->ttl, OP_EQ, 256);
   a = smartlist_get(addrs, 2);
   tt_assert(tor_addr_is_null(&a->addr));
-  tt_str_op(a->hostname, ==, "motherbrain.zebes");
-  tt_int_op(a->ttl, ==, 0);
+  tt_str_op(a->hostname, OP_EQ, "motherbrain.zebes");
+  tt_int_op(a->ttl, OP_EQ, 0);
   CLEAR_ADDRS();
 
   /* Cell with several of similar type */
@@ -1059,29 +1059,29 @@ test_cfmt_resolved_cells(void *arg)
            "\x00\x00\x00\x00\x00\xfa\xca\xde"
            "\x00\00\x00\x03");
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, 0);
-  tt_int_op(r, ==, 0);
-  tt_int_op(smartlist_len(addrs), ==, 5);
+  tt_int_op(errcode, OP_EQ, 0);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 5);
   a = smartlist_get(addrs, 0);
-  tt_str_op(fmt_addr(&a->addr), ==, "127.0.2.10");
-  tt_ptr_op(a->hostname, ==, NULL);
-  tt_int_op(a->ttl, ==, 256);
+  tt_str_op(fmt_addr(&a->addr), OP_EQ, "127.0.2.10");
+  tt_ptr_op(a->hostname, OP_EQ, NULL);
+  tt_int_op(a->ttl, OP_EQ, 256);
   a = smartlist_get(addrs, 1);
-  tt_str_op(fmt_addr(&a->addr), ==, "8.8.8.8");
-  tt_ptr_op(a->hostname, ==, NULL);
-  tt_int_op(a->ttl, ==, 261);
+  tt_str_op(fmt_addr(&a->addr), OP_EQ, "8.8.8.8");
+  tt_ptr_op(a->hostname, OP_EQ, NULL);
+  tt_int_op(a->ttl, OP_EQ, 261);
   a = smartlist_get(addrs, 2);
-  tt_str_op(fmt_addr(&a->addr), ==, "127.176.2.176");
-  tt_ptr_op(a->hostname, ==, NULL);
-  tt_int_op(a->ttl, ==, 131071);
+  tt_str_op(fmt_addr(&a->addr), OP_EQ, "127.176.2.176");
+  tt_ptr_op(a->hostname, OP_EQ, NULL);
+  tt_int_op(a->ttl, OP_EQ, 131071);
   a = smartlist_get(addrs, 3);
-  tt_str_op(fmt_addr(&a->addr), ==, "2002:9000::cafe:f00d");
-  tt_ptr_op(a->hostname, ==, NULL);
-  tt_int_op(a->ttl, ==, 1);
+  tt_str_op(fmt_addr(&a->addr), OP_EQ, "2002:9000::cafe:f00d");
+  tt_ptr_op(a->hostname, OP_EQ, NULL);
+  tt_int_op(a->ttl, OP_EQ, 1);
   a = smartlist_get(addrs, 4);
-  tt_str_op(fmt_addr(&a->addr), ==, "2002:9001::fa:cade");
-  tt_ptr_op(a->hostname, ==, NULL);
-  tt_int_op(a->ttl, ==, 3);
+  tt_str_op(fmt_addr(&a->addr), OP_EQ, "2002:9001::fa:cade");
+  tt_ptr_op(a->hostname, OP_EQ, NULL);
+  tt_int_op(a->ttl, OP_EQ, 3);
   CLEAR_ADDRS();
 
   /* Full cell */
@@ -1091,22 +1091,22 @@ test_cfmt_resolved_cells(void *arg)
   "g-case.to-avoid-off-by-one-errors.where-full-things-are-misreported-as" \
   ".overflowing-by-one.z"
 
-  tt_int_op(strlen(LONG_NAME2), ==, 231);
+  tt_int_op(strlen(LONG_NAME2), OP_EQ, 231);
   SET_CELL("\x00\xff"
            LONG_NAME
            "\x00\01\x00\x00"
            "\x00\xe7"
            LONG_NAME2
            "\x00\01\x00\x00");
-  tt_int_op(rh.length, ==, RELAY_PAYLOAD_SIZE);
+  tt_int_op(rh.length, OP_EQ, RELAY_PAYLOAD_SIZE);
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, 0);
-  tt_int_op(r, ==, 0);
-  tt_int_op(smartlist_len(addrs), ==, 2);
+  tt_int_op(errcode, OP_EQ, 0);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 2);
   a = smartlist_get(addrs, 0);
-  tt_str_op(a->hostname, ==, LONG_NAME);
+  tt_str_op(a->hostname, OP_EQ, LONG_NAME);
   a = smartlist_get(addrs, 1);
-  tt_str_op(a->hostname, ==, LONG_NAME2);
+  tt_str_op(a->hostname, OP_EQ, LONG_NAME2);
   CLEAR_ADDRS();
 
   /* BAD CELLS */
@@ -1114,49 +1114,49 @@ test_cfmt_resolved_cells(void *arg)
   /* Invalid length on an IPv4 */
   SET_CELL("\x04\x03zzz1234");
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, 0);
-  tt_int_op(r, ==, -1);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(errcode, OP_EQ, 0);
+  tt_int_op(r, OP_EQ, -1);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
   SET_CELL("\x04\x04" "\x7f\x00\x02\x0a" "\x00\00\x01\x00"
            "\x04\x05zzzzz1234");
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, 0);
-  tt_int_op(r, ==, -1);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(errcode, OP_EQ, 0);
+  tt_int_op(r, OP_EQ, -1);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
 
   /* Invalid length on an IPv6 */
   SET_CELL("\x06\x03zzz1234");
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, 0);
-  tt_int_op(r, ==, -1);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(errcode, OP_EQ, 0);
+  tt_int_op(r, OP_EQ, -1);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
   SET_CELL("\x04\x04" "\x7f\x00\x02\x0a" "\x00\00\x01\x00"
            "\x06\x17wwwwwwwwwwwwwwwww1234");
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, 0);
-  tt_int_op(r, ==, -1);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(errcode, OP_EQ, 0);
+  tt_int_op(r, OP_EQ, -1);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
   SET_CELL("\x04\x04" "\x7f\x00\x02\x0a" "\x00\00\x01\x00"
            "\x06\x10xxxx");
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, 0);
-  tt_int_op(r, ==, -1);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(errcode, OP_EQ, 0);
+  tt_int_op(r, OP_EQ, -1);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
 
   /* Empty hostname */
   SET_CELL("\x00\x00xxxx");
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, 0);
-  tt_int_op(r, ==, -1);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(errcode, OP_EQ, 0);
+  tt_int_op(r, OP_EQ, -1);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
 
   /* rh.length out of range */
   CLEAR_CELL();
   rh.length = 499;
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(errcode, ==, 0);
-  tt_int_op(r, ==, -1);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(errcode, OP_EQ, 0);
+  tt_int_op(r, OP_EQ, -1);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
 
   /* Item length extends beyond rh.length */
   CLEAR_CELL();
@@ -1165,18 +1165,18 @@ test_cfmt_resolved_cells(void *arg)
            "\x00\01\x00\x00");
   rh.length -= 1;
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(r, ==, -1);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(r, OP_EQ, -1);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
   rh.length -= 5;
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(r, ==, -1);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(r, OP_EQ, -1);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
 
   SET_CELL("\x04\x04" "\x7f\x00\x02\x0a" "\x00\00\x01\x00");
   rh.length -= 1;
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(r, ==, -1);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(r, OP_EQ, -1);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
 
   SET_CELL("\xee\x10"
            "\x20\x02\x90\x01\x00\x00\x00\x00"
@@ -1184,19 +1184,19 @@ test_cfmt_resolved_cells(void *arg)
            "\x00\00\x00\x03");
   rh.length -= 1;
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(r, ==, -1);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(r, OP_EQ, -1);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
 
   /* Truncated item after first character */
   SET_CELL("\x04");
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(r, ==, -1);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(r, OP_EQ, -1);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
 
   SET_CELL("\xee");
   r = resolved_cell_parse(&cell, &rh, addrs, &errcode);
-  tt_int_op(r, ==, -1);
-  tt_int_op(smartlist_len(addrs), ==, 0);
+  tt_int_op(r, OP_EQ, -1);
+  tt_int_op(smartlist_len(addrs), OP_EQ, 0);
 
  done:
   CLEAR_ADDRS();
@@ -1224,19 +1224,19 @@ test_cfmt_is_destroy(void *arg)
   cell_pack(&packed, &cell, 0);
   chan->wide_circ_ids = 0;
   tt_assert(! packed_cell_is_destroy(chan, &packed, &circid));
-  tt_int_op(circid, ==, 0);
+  tt_int_op(circid, OP_EQ, 0);
 
   cell_pack(&packed, &cell, 1);
   chan->wide_circ_ids = 1;
   tt_assert(! packed_cell_is_destroy(chan, &packed, &circid));
-  tt_int_op(circid, ==, 0);
+  tt_int_op(circid, OP_EQ, 0);
 
   cell.command = CELL_DESTROY;
 
   cell_pack(&packed, &cell, 0);
   chan->wide_circ_ids = 0;
   tt_assert(packed_cell_is_destroy(chan, &packed, &circid));
-  tt_int_op(circid, ==, 3003);
+  tt_int_op(circid, OP_EQ, 3003);
 
   circid = 0;
   cell_pack(&packed, &cell, 1);
diff --git a/src/test/test_cell_queue.c b/src/test/test_cell_queue.c
index e43c100..e2fc95c 100644
--- a/src/test/test_cell_queue.c
+++ b/src/test/test_cell_queue.c
@@ -21,7 +21,7 @@ test_cq_manip(void *arg)
 #endif /* ENABLE_MEMPOOLS */
 
   cell_queue_init(&cq);
-  tt_int_op(cq.n, ==, 0);
+  tt_int_op(cq.n, OP_EQ, 0);
 
   pc1 = packed_cell_new();
   pc2 = packed_cell_new();
@@ -29,26 +29,26 @@ test_cq_manip(void *arg)
   pc4 = packed_cell_new();
   tt_assert(pc1 && pc2 && pc3 && pc4);
 
-  tt_ptr_op(NULL, ==, cell_queue_pop(&cq));
+  tt_ptr_op(NULL, OP_EQ, cell_queue_pop(&cq));
 
   /* Add and remove a singleton. */
   cell_queue_append(&cq, pc1);
-  tt_int_op(cq.n, ==, 1);
-  tt_ptr_op(pc1, ==, cell_queue_pop(&cq));
-  tt_int_op(cq.n, ==, 0);
+  tt_int_op(cq.n, OP_EQ, 1);
+  tt_ptr_op(pc1, OP_EQ, cell_queue_pop(&cq));
+  tt_int_op(cq.n, OP_EQ, 0);
 
   /* Add and remove four items */
   cell_queue_append(&cq, pc4);
   cell_queue_append(&cq, pc3);
   cell_queue_append(&cq, pc2);
   cell_queue_append(&cq, pc1);
-  tt_int_op(cq.n, ==, 4);
-  tt_ptr_op(pc4, ==, cell_queue_pop(&cq));
-  tt_ptr_op(pc3, ==, cell_queue_pop(&cq));
-  tt_ptr_op(pc2, ==, cell_queue_pop(&cq));
-  tt_ptr_op(pc1, ==, cell_queue_pop(&cq));
-  tt_int_op(cq.n, ==, 0);
-  tt_ptr_op(NULL, ==, cell_queue_pop(&cq));
+  tt_int_op(cq.n, OP_EQ, 4);
+  tt_ptr_op(pc4, OP_EQ, cell_queue_pop(&cq));
+  tt_ptr_op(pc3, OP_EQ, cell_queue_pop(&cq));
+  tt_ptr_op(pc2, OP_EQ, cell_queue_pop(&cq));
+  tt_ptr_op(pc1, OP_EQ, cell_queue_pop(&cq));
+  tt_int_op(cq.n, OP_EQ, 0);
+  tt_ptr_op(NULL, OP_EQ, cell_queue_pop(&cq));
 
   /* Try a packed copy (wide, then narrow, which is a bit of a cheat, since a
    * real cell queue has only one type.) */
@@ -64,32 +64,32 @@ test_cq_manip(void *arg)
   cell.circ_id = 0x2013;
   cell_queue_append_packed_copy(NULL /*circ*/, &cq, 0 /*exitward*/, &cell,
                                 0 /*wide*/, 0 /*stats*/);
-  tt_int_op(cq.n, ==, 2);
+  tt_int_op(cq.n, OP_EQ, 2);
 
   pc_tmp = cell_queue_pop(&cq);
-  tt_int_op(cq.n, ==, 1);
-  tt_ptr_op(pc_tmp, !=, NULL);
-  tt_mem_op(pc_tmp->body, ==, "\x12\x34\x56\x78\x0a", 5);
-  tt_mem_op(pc_tmp->body+5, ==, cell.payload, sizeof(cell.payload));
+  tt_int_op(cq.n, OP_EQ, 1);
+  tt_ptr_op(pc_tmp, OP_NE, NULL);
+  tt_mem_op(pc_tmp->body, OP_EQ, "\x12\x34\x56\x78\x0a", 5);
+  tt_mem_op(pc_tmp->body+5, OP_EQ, 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);
-  tt_mem_op(pc_tmp->body, ==, "\x20\x13\x0a", 3);
-  tt_mem_op(pc_tmp->body+3, ==, cell.payload, sizeof(cell.payload));
+  tt_int_op(cq.n, OP_EQ, 0);
+  tt_ptr_op(pc_tmp, OP_NE, NULL);
+  tt_mem_op(pc_tmp->body, OP_EQ, "\x20\x13\x0a", 3);
+  tt_mem_op(pc_tmp->body+3, OP_EQ, cell.payload, sizeof(cell.payload));
   packed_cell_free(pc_tmp);
   pc_tmp = NULL;
 
-  tt_ptr_op(NULL, ==, cell_queue_pop(&cq));
+  tt_ptr_op(NULL, OP_EQ, cell_queue_pop(&cq));
 
   /* Now make sure cell_queue_clear works. */
   cell_queue_append(&cq, pc2);
   cell_queue_append(&cq, pc1);
-  tt_int_op(cq.n, ==, 2);
+  tt_int_op(cq.n, OP_EQ, 2);
   cell_queue_clear(&cq);
   pc2 = pc1 = NULL; /* prevent double-free */
-  tt_int_op(cq.n, ==, 0);
+  tt_int_op(cq.n, OP_EQ, 0);
 
  done:
   packed_cell_free(pc1);
@@ -129,17 +129,17 @@ test_circuit_n_cells(void *arg)
   origin_c = origin_circuit_new();
   origin_c->base_.purpose = CIRCUIT_PURPOSE_C_GENERAL;
 
-  tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(or_c)), ==, 0);
+  tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(or_c)), OP_EQ, 0);
   cell_queue_append(&or_c->p_chan_cells, pc1);
-  tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(or_c)), ==, 1);
+  tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(or_c)), OP_EQ, 1);
   cell_queue_append(&or_c->base_.n_chan_cells, pc2);
   cell_queue_append(&or_c->base_.n_chan_cells, pc3);
-  tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(or_c)), ==, 3);
+  tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(or_c)), OP_EQ, 3);
 
-  tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(origin_c)), ==, 0);
+  tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(origin_c)), OP_EQ, 0);
   cell_queue_append(&origin_c->base_.n_chan_cells, pc4);
   cell_queue_append(&origin_c->base_.n_chan_cells, pc5);
-  tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(origin_c)), ==, 2);
+  tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(origin_c)), OP_EQ, 2);
 
  done:
   circuit_free(TO_CIRCUIT(or_c));
diff --git a/src/test/test_checkdir.c b/src/test/test_checkdir.c
index 5135816..6c52065 100644
--- a/src/test/test_checkdir.c
+++ b/src/test/test_checkdir.c
@@ -31,41 +31,41 @@ test_checkdir_perms(void *testdata)
   /* setup data directory before tests. */
   tor_free(options->DataDirectory);
   options->DataDirectory = tor_strdup(get_fname(subdir));
-  tt_int_op(mkdir(options->DataDirectory, 0750), ==, 0);
+  tt_int_op(mkdir(options->DataDirectory, 0750), OP_EQ, 0);
 
   /* test: create new dir, no flags. */
   testdir = get_datadir_fname("checkdir_new_none");
   cpd_chkopts = CPD_CREATE;
   unix_verify_optsmask = 0077;
-  tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL));
-  tt_int_op(0, ==, stat(testdir, &st));
-  tt_int_op_nowin(0, ==, (st.st_mode & unix_verify_optsmask));
+  tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL));
+  tt_int_op(0, OP_EQ, stat(testdir, &st));
+  tt_int_op_nowin(0, OP_EQ, (st.st_mode & unix_verify_optsmask));
   tor_free(testdir);
 
   /* test: create new dir, CPD_GROUP_OK option set. */
   testdir = get_datadir_fname("checkdir_new_groupok");
   cpd_chkopts = CPD_CREATE|CPD_GROUP_OK;
   unix_verify_optsmask = 0077;
-  tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL));
-  tt_int_op(0, ==, stat(testdir, &st));
-  tt_int_op_nowin(0, ==, (st.st_mode & unix_verify_optsmask));
+  tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL));
+  tt_int_op(0, OP_EQ, stat(testdir, &st));
+  tt_int_op_nowin(0, OP_EQ, (st.st_mode & unix_verify_optsmask));
   tor_free(testdir);
 
   /* test: should get an error on existing dir with
            wrong perms */
   testdir = get_datadir_fname("checkdir_new_groupok_err");
-  tt_int_op(0, ==, mkdir(testdir, 027));
+  tt_int_op(0, OP_EQ, mkdir(testdir, 027));
   cpd_chkopts = CPD_CHECK_MODE_ONLY|CPD_CREATE|CPD_GROUP_OK;
-  tt_int_op_nowin(-1, ==, check_private_dir(testdir, cpd_chkopts, NULL));
+  tt_int_op_nowin(-1, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL));
   tor_free(testdir);
 
   /* test: create new dir, CPD_GROUP_READ option set. */
   testdir = get_datadir_fname("checkdir_new_groupread");
   cpd_chkopts = CPD_CREATE|CPD_GROUP_READ;
   unix_verify_optsmask = 0027;
-  tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL));
-  tt_int_op(0, ==, stat(testdir, &st));
-  tt_int_op_nowin(0, ==, (st.st_mode & unix_verify_optsmask));
+  tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL));
+  tt_int_op(0, OP_EQ, stat(testdir, &st));
+  tt_int_op_nowin(0, OP_EQ, (st.st_mode & unix_verify_optsmask));
   tor_free(testdir);
 
   /* test: check existing dir created with defaults,
@@ -75,10 +75,10 @@ test_checkdir_perms(void *testdata)
   unix_create_opts = 0700;
   (void)unix_create_opts;
   unix_verify_optsmask = 0077;
-  tt_int_op(0, ==, mkdir(testdir, unix_create_opts));
-  tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL));
-  tt_int_op(0, ==, stat(testdir, &st));
-  tt_int_op_nowin(0, ==, (st.st_mode & unix_verify_optsmask));
+  tt_int_op(0, OP_EQ, mkdir(testdir, unix_create_opts));
+  tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL));
+  tt_int_op(0, OP_EQ, stat(testdir, &st));
+  tt_int_op_nowin(0, OP_EQ, (st.st_mode & unix_verify_optsmask));
   tor_free(testdir);
 
   /* test: check existing dir created with defaults,
@@ -86,11 +86,11 @@ test_checkdir_perms(void *testdata)
   testdir = get_datadir_fname("checkdir_exists_groupok");
   cpd_chkopts = CPD_CREATE;
   unix_verify_optsmask = 0077;
-  tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL));
+  tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL));
   cpd_chkopts = CPD_GROUP_OK;
-  tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL));
-  tt_int_op(0, ==, stat(testdir, &st));
-  tt_int_op_nowin(0, ==, (st.st_mode & unix_verify_optsmask));
+  tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL));
+  tt_int_op(0, OP_EQ, stat(testdir, &st));
+  tt_int_op_nowin(0, OP_EQ, (st.st_mode & unix_verify_optsmask));
   tor_free(testdir);
 
   /* test: check existing dir created with defaults,
@@ -98,11 +98,11 @@ test_checkdir_perms(void *testdata)
   testdir = get_datadir_fname("checkdir_exists_groupread");
   cpd_chkopts = CPD_CREATE;
   unix_verify_optsmask = 0027;
-  tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL));
+  tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL));
   cpd_chkopts = CPD_GROUP_READ;
-  tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL));
-  tt_int_op(0, ==, stat(testdir, &st));
-  tt_int_op_nowin(0, ==, (st.st_mode & unix_verify_optsmask));
+  tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL));
+  tt_int_op(0, OP_EQ, stat(testdir, &st));
+  tt_int_op_nowin(0, OP_EQ, (st.st_mode & unix_verify_optsmask));
   tor_free(testdir);
 
   /* test: check existing dir created with CPD_GROUP_READ,
@@ -110,11 +110,11 @@ test_checkdir_perms(void *testdata)
   testdir = get_datadir_fname("checkdir_existsread_groupok");
   cpd_chkopts = CPD_CREATE|CPD_GROUP_READ;
   unix_verify_optsmask = 0027;
-  tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL));
+  tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL));
   cpd_chkopts = CPD_GROUP_OK;
-  tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL));
-  tt_int_op(0, ==, stat(testdir, &st));
-  tt_int_op_nowin(0, ==, (st.st_mode & unix_verify_optsmask));
+  tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL));
+  tt_int_op(0, OP_EQ, stat(testdir, &st));
+  tt_int_op_nowin(0, OP_EQ, (st.st_mode & unix_verify_optsmask));
   tor_free(testdir);
 
   /* test: check existing dir created with CPD_GROUP_READ,
@@ -122,9 +122,9 @@ test_checkdir_perms(void *testdata)
   testdir = get_datadir_fname("checkdir_existsread_groupread");
   cpd_chkopts = CPD_CREATE|CPD_GROUP_READ;
   unix_verify_optsmask = 0027;
-  tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL));
-  tt_int_op(0, ==, stat(testdir, &st));
-  tt_int_op_nowin(0, ==, (st.st_mode & unix_verify_optsmask));
+  tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL));
+  tt_int_op(0, OP_EQ, stat(testdir, &st));
+  tt_int_op_nowin(0, OP_EQ, (st.st_mode & unix_verify_optsmask));
 
  done:
   tor_free(testdir);
diff --git a/src/test/test_circuitlist.c b/src/test/test_circuitlist.c
index fb5488b..181aec2 100644
--- a/src/test/test_circuitlist.c
+++ b/src/test/test_circuitlist.c
@@ -50,17 +50,17 @@ circuitmux_detach_mock(circuitmux_t *cmux, circuit_t *circ)
 }
 
 #define GOT_CMUX_ATTACH(mux_, circ_, dir_) do {  \
-    tt_int_op(cam.ncalls, ==, 1);                \
-    tt_ptr_op(cam.cmux, ==, (mux_));             \
-    tt_ptr_op(cam.circ, ==, (circ_));            \
-    tt_int_op(cam.dir, ==, (dir_));              \
+    tt_int_op(cam.ncalls, OP_EQ, 1);                \
+    tt_ptr_op(cam.cmux, OP_EQ, (mux_));             \
+    tt_ptr_op(cam.circ, OP_EQ, (circ_));            \
+    tt_int_op(cam.dir, OP_EQ, (dir_));              \
     memset(&cam, 0, sizeof(cam));                \
   } while (0)
 
 #define GOT_CMUX_DETACH(mux_, circ_) do {        \
-    tt_int_op(cdm.ncalls, ==, 1);                \
-    tt_ptr_op(cdm.cmux, ==, (mux_));             \
-    tt_ptr_op(cdm.circ, ==, (circ_));            \
+    tt_int_op(cdm.ncalls, OP_EQ, 1);                \
+    tt_ptr_op(cdm.cmux, OP_EQ, (mux_));             \
+    tt_ptr_op(cdm.circ, OP_EQ, (circ_));            \
     memset(&cdm, 0, sizeof(cdm));                \
   } while (0)
 
@@ -90,14 +90,14 @@ test_clist_maps(void *arg)
   or_c1 = or_circuit_new(100, ch2);
   tt_assert(or_c1);
   GOT_CMUX_ATTACH(ch2->cmux, or_c1, CELL_DIRECTION_IN);
-  tt_int_op(or_c1->p_circ_id, ==, 100);
-  tt_ptr_op(or_c1->p_chan, ==, ch2);
+  tt_int_op(or_c1->p_circ_id, OP_EQ, 100);
+  tt_ptr_op(or_c1->p_chan, OP_EQ, ch2);
 
   or_c2 = or_circuit_new(100, ch1);
   tt_assert(or_c2);
   GOT_CMUX_ATTACH(ch1->cmux, or_c2, CELL_DIRECTION_IN);
-  tt_int_op(or_c2->p_circ_id, ==, 100);
-  tt_ptr_op(or_c2->p_chan, ==, ch1);
+  tt_int_op(or_c2->p_circ_id, OP_EQ, 100);
+  tt_ptr_op(or_c2->p_chan, OP_EQ, ch1);
 
   circuit_set_n_circid_chan(TO_CIRCUIT(or_c1), 200, ch1);
   GOT_CMUX_ATTACH(ch1->cmux, or_c1, CELL_DIRECTION_OUT);
@@ -105,11 +105,11 @@ test_clist_maps(void *arg)
   circuit_set_n_circid_chan(TO_CIRCUIT(or_c2), 200, ch2);
   GOT_CMUX_ATTACH(ch2->cmux, or_c2, CELL_DIRECTION_OUT);
 
-  tt_ptr_op(circuit_get_by_circid_channel(200, ch1), ==, TO_CIRCUIT(or_c1));
-  tt_ptr_op(circuit_get_by_circid_channel(200, ch2), ==, TO_CIRCUIT(or_c2));
-  tt_ptr_op(circuit_get_by_circid_channel(100, ch2), ==, TO_CIRCUIT(or_c1));
+  tt_ptr_op(circuit_get_by_circid_channel(200, ch1), OP_EQ, TO_CIRCUIT(or_c1));
+  tt_ptr_op(circuit_get_by_circid_channel(200, ch2), OP_EQ, TO_CIRCUIT(or_c2));
+  tt_ptr_op(circuit_get_by_circid_channel(100, ch2), OP_EQ, TO_CIRCUIT(or_c1));
   /* Try the same thing again, to test the "fast" path. */
-  tt_ptr_op(circuit_get_by_circid_channel(100, ch2), ==, TO_CIRCUIT(or_c1));
+  tt_ptr_op(circuit_get_by_circid_channel(100, ch2), OP_EQ, TO_CIRCUIT(or_c1));
   tt_assert(circuit_id_in_use_on_channel(100, ch2));
   tt_assert(! circuit_id_in_use_on_channel(101, ch2));
 
@@ -117,9 +117,9 @@ test_clist_maps(void *arg)
   circuit_set_p_circid_chan(or_c1, 500, ch3);
   GOT_CMUX_DETACH(ch2->cmux, TO_CIRCUIT(or_c1));
   GOT_CMUX_ATTACH(ch3->cmux, TO_CIRCUIT(or_c1), CELL_DIRECTION_IN);
-  tt_ptr_op(circuit_get_by_circid_channel(100, ch2), ==, NULL);
+  tt_ptr_op(circuit_get_by_circid_channel(100, ch2), OP_EQ, NULL);
   tt_assert(! circuit_id_in_use_on_channel(100, ch2));
-  tt_ptr_op(circuit_get_by_circid_channel(500, ch3), ==, TO_CIRCUIT(or_c1));
+  tt_ptr_op(circuit_get_by_circid_channel(500, ch3), OP_EQ, TO_CIRCUIT(or_c1));
 
   /* Now let's see about destroy handling. */
   tt_assert(! circuit_id_in_use_on_channel(205, ch2));
@@ -132,26 +132,26 @@ test_clist_maps(void *arg)
   tt_assert(circuit_id_in_use_on_channel(100, ch1));
 
   tt_assert(TO_CIRCUIT(or_c2)->n_delete_pending != 0);
-  tt_ptr_op(circuit_get_by_circid_channel(200, ch2), ==, TO_CIRCUIT(or_c2));
-  tt_ptr_op(circuit_get_by_circid_channel(100, ch1), ==, TO_CIRCUIT(or_c2));
+  tt_ptr_op(circuit_get_by_circid_channel(200, ch2), OP_EQ, TO_CIRCUIT(or_c2));
+  tt_ptr_op(circuit_get_by_circid_channel(100, ch1), OP_EQ, TO_CIRCUIT(or_c2));
 
   /* Okay, now free ch2 and make sure that the circuit ID is STILL not
    * usable, because we haven't declared the destroy to be nonpending */
-  tt_int_op(cdm.ncalls, ==, 0);
+  tt_int_op(cdm.ncalls, OP_EQ, 0);
   circuit_free(TO_CIRCUIT(or_c2));
   or_c2 = NULL; /* prevent free */
-  tt_int_op(cdm.ncalls, ==, 2);
+  tt_int_op(cdm.ncalls, OP_EQ, 2);
   memset(&cdm, 0, sizeof(cdm));
   tt_assert(circuit_id_in_use_on_channel(200, ch2));
   tt_assert(circuit_id_in_use_on_channel(100, ch1));
-  tt_ptr_op(circuit_get_by_circid_channel(200, ch2), ==, NULL);
-  tt_ptr_op(circuit_get_by_circid_channel(100, ch1), ==, NULL);
+  tt_ptr_op(circuit_get_by_circid_channel(200, ch2), OP_EQ, NULL);
+  tt_ptr_op(circuit_get_by_circid_channel(100, ch1), OP_EQ, NULL);
 
   /* Now say that the destroy is nonpending */
   channel_note_destroy_not_pending(ch2, 200);
-  tt_ptr_op(circuit_get_by_circid_channel(200, ch2), ==, NULL);
+  tt_ptr_op(circuit_get_by_circid_channel(200, ch2), OP_EQ, NULL);
   channel_note_destroy_not_pending(ch1, 100);
-  tt_ptr_op(circuit_get_by_circid_channel(100, ch1), ==, NULL);
+  tt_ptr_op(circuit_get_by_circid_channel(100, ch1), OP_EQ, NULL);
   tt_assert(! circuit_id_in_use_on_channel(200, ch2));
   tt_assert(! circuit_id_in_use_on_channel(100, ch1));
 
@@ -190,73 +190,73 @@ test_rend_token_maps(void *arg)
   c4 = or_circuit_new(0, NULL);
 
   /* Make sure we really filled up the tok* variables */
-  tt_int_op(tok1[REND_TOKEN_LEN-1], ==, 'y');
-  tt_int_op(tok2[REND_TOKEN_LEN-1], ==, ' ');
-  tt_int_op(tok3[REND_TOKEN_LEN-1], ==, '.');
+  tt_int_op(tok1[REND_TOKEN_LEN-1], OP_EQ, 'y');
+  tt_int_op(tok2[REND_TOKEN_LEN-1], OP_EQ, ' ');
+  tt_int_op(tok3[REND_TOKEN_LEN-1], OP_EQ, '.');
 
   /* No maps; nothing there. */
-  tt_ptr_op(NULL, ==, circuit_get_rendezvous(tok1));
-  tt_ptr_op(NULL, ==, circuit_get_intro_point(tok1));
+  tt_ptr_op(NULL, OP_EQ, circuit_get_rendezvous(tok1));
+  tt_ptr_op(NULL, OP_EQ, circuit_get_intro_point(tok1));
 
   circuit_set_rendezvous_cookie(c1, tok1);
   circuit_set_intro_point_digest(c2, tok2);
 
-  tt_ptr_op(NULL, ==, circuit_get_rendezvous(tok3));
-  tt_ptr_op(NULL, ==, circuit_get_intro_point(tok3));
-  tt_ptr_op(NULL, ==, circuit_get_rendezvous(tok2));
-  tt_ptr_op(NULL, ==, circuit_get_intro_point(tok1));
+  tt_ptr_op(NULL, OP_EQ, circuit_get_rendezvous(tok3));
+  tt_ptr_op(NULL, OP_EQ, circuit_get_intro_point(tok3));
+  tt_ptr_op(NULL, OP_EQ, circuit_get_rendezvous(tok2));
+  tt_ptr_op(NULL, OP_EQ, circuit_get_intro_point(tok1));
 
   /* Without purpose set, we don't get the circuits */
-  tt_ptr_op(NULL, ==, circuit_get_rendezvous(tok1));
-  tt_ptr_op(NULL, ==, circuit_get_intro_point(tok2));
+  tt_ptr_op(NULL, OP_EQ, circuit_get_rendezvous(tok1));
+  tt_ptr_op(NULL, OP_EQ, circuit_get_intro_point(tok2));
 
   c1->base_.purpose = CIRCUIT_PURPOSE_REND_POINT_WAITING;
   c2->base_.purpose = CIRCUIT_PURPOSE_INTRO_POINT;
 
   /* Okay, make sure they show up now. */
-  tt_ptr_op(c1, ==, circuit_get_rendezvous(tok1));
-  tt_ptr_op(c2, ==, circuit_get_intro_point(tok2));
+  tt_ptr_op(c1, OP_EQ, circuit_get_rendezvous(tok1));
+  tt_ptr_op(c2, OP_EQ, circuit_get_intro_point(tok2));
 
   /* Two items at the same place with the same token. */
   c3->base_.purpose = CIRCUIT_PURPOSE_REND_POINT_WAITING;
   circuit_set_rendezvous_cookie(c3, tok2);
-  tt_ptr_op(c2, ==, circuit_get_intro_point(tok2));
-  tt_ptr_op(c3, ==, circuit_get_rendezvous(tok2));
+  tt_ptr_op(c2, OP_EQ, circuit_get_intro_point(tok2));
+  tt_ptr_op(c3, OP_EQ, circuit_get_rendezvous(tok2));
 
   /* Marking a circuit makes it not get returned any more */
   circuit_mark_for_close(TO_CIRCUIT(c1), END_CIRC_REASON_FINISHED);
-  tt_ptr_op(NULL, ==, circuit_get_rendezvous(tok1));
+  tt_ptr_op(NULL, OP_EQ, circuit_get_rendezvous(tok1));
   circuit_free(TO_CIRCUIT(c1));
   c1 = NULL;
 
   /* Freeing a circuit makes it not get returned any more. */
   circuit_free(TO_CIRCUIT(c2));
   c2 = NULL;
-  tt_ptr_op(NULL, ==, circuit_get_intro_point(tok2));
+  tt_ptr_op(NULL, OP_EQ, circuit_get_intro_point(tok2));
 
   /* c3 -- are you still there? */
-  tt_ptr_op(c3, ==, circuit_get_rendezvous(tok2));
+  tt_ptr_op(c3, OP_EQ, circuit_get_rendezvous(tok2));
   /* Change its cookie.  This never happens in Tor per se, but hey. */
   c3->base_.purpose = CIRCUIT_PURPOSE_INTRO_POINT;
   circuit_set_intro_point_digest(c3, tok3);
 
-  tt_ptr_op(NULL, ==, circuit_get_rendezvous(tok2));
-  tt_ptr_op(c3, ==, circuit_get_intro_point(tok3));
+  tt_ptr_op(NULL, OP_EQ, circuit_get_rendezvous(tok2));
+  tt_ptr_op(c3, OP_EQ, circuit_get_intro_point(tok3));
 
   /* Now replace c3 with c4. */
   c4->base_.purpose = CIRCUIT_PURPOSE_INTRO_POINT;
   circuit_set_intro_point_digest(c4, tok3);
 
-  tt_ptr_op(c4, ==, circuit_get_intro_point(tok3));
+  tt_ptr_op(c4, OP_EQ, circuit_get_intro_point(tok3));
 
-  tt_ptr_op(c3->rendinfo, ==, NULL);
-  tt_ptr_op(c4->rendinfo, !=, NULL);
-  tt_mem_op(c4->rendinfo, ==, tok3, REND_TOKEN_LEN);
+  tt_ptr_op(c3->rendinfo, OP_EQ, NULL);
+  tt_ptr_op(c4->rendinfo, OP_NE, NULL);
+  tt_mem_op(c4->rendinfo, OP_EQ, tok3, REND_TOKEN_LEN);
 
   /* Now clear c4's cookie. */
   circuit_set_intro_point_digest(c4, NULL);
-  tt_ptr_op(c4->rendinfo, ==, NULL);
-  tt_ptr_op(NULL, ==, circuit_get_intro_point(tok3));
+  tt_ptr_op(c4->rendinfo, OP_EQ, NULL);
+  tt_ptr_op(NULL, OP_EQ, circuit_get_intro_point(tok3));
 
  done:
   if (c1)
@@ -283,32 +283,32 @@ test_pick_circid(void *arg)
   chan2->wide_circ_ids = 1;
 
   chan1->circ_id_type = CIRC_ID_TYPE_NEITHER;
-  tt_int_op(0, ==, get_unique_circ_id_by_chan(chan1));
+  tt_int_op(0, OP_EQ, get_unique_circ_id_by_chan(chan1));
 
   /* Basic tests, with no collisions */
   chan1->circ_id_type = CIRC_ID_TYPE_LOWER;
   for (i = 0; i < 50; ++i) {
     circid = get_unique_circ_id_by_chan(chan1);
-    tt_uint_op(0, <, circid);
-    tt_uint_op(circid, <, (1<<15));
+    tt_uint_op(0, OP_LT, circid);
+    tt_uint_op(circid, OP_LT, (1<<15));
   }
   chan1->circ_id_type = CIRC_ID_TYPE_HIGHER;
   for (i = 0; i < 50; ++i) {
     circid = get_unique_circ_id_by_chan(chan1);
-    tt_uint_op((1<<15), <, circid);
-    tt_uint_op(circid, <, (1<<16));
+    tt_uint_op((1<<15), OP_LT, circid);
+    tt_uint_op(circid, OP_LT, (1<<16));
   }
 
   chan2->circ_id_type = CIRC_ID_TYPE_LOWER;
   for (i = 0; i < 50; ++i) {
     circid = get_unique_circ_id_by_chan(chan2);
-    tt_uint_op(0, <, circid);
-    tt_uint_op(circid, <, (1u<<31));
+    tt_uint_op(0, OP_LT, circid);
+    tt_uint_op(circid, OP_LT, (1u<<31));
   }
   chan2->circ_id_type = CIRC_ID_TYPE_HIGHER;
   for (i = 0; i < 50; ++i) {
     circid = get_unique_circ_id_by_chan(chan2);
-    tt_uint_op((1u<<31), <, circid);
+    tt_uint_op((1u<<31), OP_LT, circid);
   }
 
   /* Now make sure that we can behave well when we are full up on circuits */
@@ -319,20 +319,20 @@ test_pick_circid(void *arg)
   for (i = 0; i < (1<<15); ++i) {
     circid = get_unique_circ_id_by_chan(chan1);
     if (circid == 0) {
-      tt_int_op(i, >, (1<<14));
+      tt_int_op(i, OP_GT, (1<<14));
       break;
     }
-    tt_uint_op(circid, <, (1<<15));
+    tt_uint_op(circid, OP_LT, (1<<15));
     tt_assert(! bitarray_is_set(ba, circid));
     bitarray_set(ba, circid);
     channel_mark_circid_unusable(chan1, circid);
   }
-  tt_int_op(i, <, (1<<15));
+  tt_int_op(i, OP_LT, (1<<15));
   /* Make sure that being full on chan1 does not interfere with chan2 */
   for (i = 0; i < 100; ++i) {
     circid = get_unique_circ_id_by_chan(chan2);
-    tt_uint_op(circid, >, 0);
-    tt_uint_op(circid, <, (1<<15));
+    tt_uint_op(circid, OP_GT, 0);
+    tt_uint_op(circid, OP_LT, (1<<15));
     channel_mark_circid_unusable(chan2, circid);
   }
 
diff --git a/src/test/test_circuitmux.c b/src/test/test_circuitmux.c
index 446fc88..b8590d6 100644
--- a/src/test/test_circuitmux.c
+++ b/src/test/test_circuitmux.c
@@ -55,21 +55,21 @@ test_cmux_destroy_cell_queue(void *arg)
   circuitmux_append_destroy_cell(ch, cmux, 190, 6);
   circuitmux_append_destroy_cell(ch, cmux, 30, 1);
 
-  tt_int_op(circuitmux_num_cells(cmux), ==, 3);
+  tt_int_op(circuitmux_num_cells(cmux), OP_EQ, 3);
 
   circ = circuitmux_get_first_active_circuit(cmux, &cq);
   tt_assert(!circ);
   tt_assert(cq);
 
-  tt_int_op(cq->n, ==, 3);
+  tt_int_op(cq->n, OP_EQ, 3);
 
   pc = cell_queue_pop(cq);
   tt_assert(pc);
-  tt_mem_op(pc->body, ==, "\x00\x00\x00\x64\x04\x0a\x00\x00\x00", 9);
+  tt_mem_op(pc->body, OP_EQ, "\x00\x00\x00\x64\x04\x0a\x00\x00\x00", 9);
   packed_cell_free(pc);
   pc = NULL;
 
-  tt_int_op(circuitmux_num_cells(cmux), ==, 2);
+  tt_int_op(circuitmux_num_cells(cmux), OP_EQ, 2);
 
  done:
   circuitmux_free(cmux);
diff --git a/src/test/test_config.c b/src/test/test_config.c
index 71c338e..1560c5c 100644
--- a/src/test/test_config.c
+++ b/src/test/test_config.c
@@ -65,22 +65,22 @@ test_config_addressmap(void *arg)
   /* MapAddress .google.com .torserver.exit */
   strlcpy(address, "reader.google.com", sizeof(address));
   tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  tt_str_op(address,==, "reader.torserver.exit");
+  tt_str_op(address,OP_EQ, "reader.torserver.exit");
 
   /* MapAddress *.yahoo.com *.google.com.torserver.exit */
   strlcpy(address, "reader.yahoo.com", sizeof(address));
   tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  tt_str_op(address,==, "reader.google.com.torserver.exit");
+  tt_str_op(address,OP_EQ, "reader.google.com.torserver.exit");
 
   /*MapAddress *.cnn.com www.cnn.com */
   strlcpy(address, "cnn.com", sizeof(address));
   tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  tt_str_op(address,==, "www.cnn.com");
+  tt_str_op(address,OP_EQ, "www.cnn.com");
 
   /* MapAddress .cn.com www.cnn.com */
   strlcpy(address, "www.cn.com", sizeof(address));
   tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  tt_str_op(address,==, "www.cnn.com");
+  tt_str_op(address,OP_EQ, "www.cnn.com");
 
   /* MapAddress ex.com www.cnn.com  - no match */
   strlcpy(address, "www.ex.com", sizeof(address));
@@ -93,19 +93,19 @@ test_config_addressmap(void *arg)
   /* Where mapping for FQDN match on FQDN */
   strlcpy(address, "www.google.com", sizeof(address));
   tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  tt_str_op(address,==, "3.3.3.3");
+  tt_str_op(address,OP_EQ, "3.3.3.3");
 
   strlcpy(address, "www.torproject.org", sizeof(address));
   tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  tt_str_op(address,==, "1.1.1.1");
+  tt_str_op(address,OP_EQ, "1.1.1.1");
 
   strlcpy(address, "other.torproject.org", sizeof(address));
   tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  tt_str_op(address,==, "this.torproject.org.otherserver.exit");
+  tt_str_op(address,OP_EQ, "this.torproject.org.otherserver.exit");
 
   strlcpy(address, "test.torproject.org", sizeof(address));
   tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  tt_str_op(address,==, "2.2.2.2");
+  tt_str_op(address,OP_EQ, "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"
@@ -114,12 +114,12 @@ test_config_addressmap(void *arg)
   */
   strlcpy(address, "www.example.org", sizeof(address));
   tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  tt_str_op(address,==, "5.5.5.5");
+  tt_str_op(address,OP_EQ, "5.5.5.5");
 
   /* Test infinite address mapping results in no change */
   strlcpy(address, "www.infiniteloop.org", sizeof(address));
   tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  tt_str_op(address,==, "www.infiniteloop.org");
+  tt_str_op(address,OP_EQ, "www.infiniteloop.org");
 
   /* Test we don't find false positives */
   strlcpy(address, "www.example.com", sizeof(address));
@@ -137,23 +137,23 @@ test_config_addressmap(void *arg)
 
   strlcpy(address, "www.abc.com", sizeof(address));
   tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  tt_str_op(address,==, "www.abc.torserver.exit");
+  tt_str_op(address,OP_EQ, "www.abc.torserver.exit");
 
   strlcpy(address, "www.def.com", sizeof(address));
   tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  tt_str_op(address,==, "www.def.torserver.exit");
+  tt_str_op(address,OP_EQ, "www.def.torserver.exit");
 
   strlcpy(address, "www.torproject.org", sizeof(address));
   tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  tt_str_op(address,==, "1.1.1.1");
+  tt_str_op(address,OP_EQ, "1.1.1.1");
 
   strlcpy(address, "test.torproject.org", sizeof(address));
   tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  tt_str_op(address,==, "1.1.1.1");
+  tt_str_op(address,OP_EQ, "1.1.1.1");
 
   strlcpy(address, "torproject.net", sizeof(address));
   tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL));
-  tt_str_op(address,==, "2.2.2.2");
+  tt_str_op(address,OP_EQ, "2.2.2.2");
 
   /* We don't support '*' as a mapping directive */
   config_free_lines(get_options_mutable()->AddressMap);
@@ -213,9 +213,9 @@ test_config_check_or_create_data_subdir(void *arg)
   subpath = get_datadir_fname(subdir);
 
 #if defined (_WIN32)
-  tt_int_op(mkdir(options->DataDirectory), ==, 0);
+  tt_int_op(mkdir(options->DataDirectory), OP_EQ, 0);
 #else
-  tt_int_op(mkdir(options->DataDirectory, 0700), ==, 0);
+  tt_int_op(mkdir(options->DataDirectory, 0700), OP_EQ, 0);
 #endif
 
   r = stat(subpath, &st);
@@ -287,9 +287,9 @@ test_config_write_to_data_subdir(void *arg)
   filepath = get_datadir_fname2(subdir, fname);
 
 #if defined (_WIN32)
-  tt_int_op(mkdir(options->DataDirectory), ==, 0);
+  tt_int_op(mkdir(options->DataDirectory), OP_EQ, 0);
 #else
-  tt_int_op(mkdir(options->DataDirectory, 0700), ==, 0);
+  tt_int_op(mkdir(options->DataDirectory, 0700), OP_EQ, 0);
 #endif
 
   // Write attempt shoudl fail, if subdirectory doesn't exist.
@@ -300,13 +300,13 @@ test_config_write_to_data_subdir(void *arg)
   // equal to the original string.
   tt_assert(!write_to_data_subdir(subdir, fname, str, NULL));
   cp = read_file_to_str(filepath, 0, NULL);
-  tt_str_op(cp,==, str);
+  tt_str_op(cp,OP_EQ, str);
   tor_free(cp);
 
   // A second write operation should overwrite the old content.
   tt_assert(!write_to_data_subdir(subdir, fname, str, NULL));
   cp = read_file_to_str(filepath, 0, NULL);
-  tt_str_op(cp,==, str);
+  tt_str_op(cp,OP_EQ, str);
   tor_free(cp);
 
  done:
@@ -331,7 +331,7 @@ good_bridge_line_test(const char *string, const char *test_addrport,
 
   /* test addrport */
   tmp = tor_strdup(fmt_addrport(&bridge_line->addr, bridge_line->port));
-  tt_str_op(test_addrport,==, tmp);
+  tt_str_op(test_addrport,OP_EQ, tmp);
   tor_free(tmp);
 
   /* If we were asked to validate a digest, but we did not get a
@@ -349,7 +349,7 @@ good_bridge_line_test(const char *string, const char *test_addrport,
   if (test_digest) {
     tmp = tor_strdup(hex_str(bridge_line->digest, DIGEST_LEN));
     tor_strlower(tmp);
-    tt_str_op(test_digest,==, tmp);
+    tt_str_op(test_digest,OP_EQ, tmp);
     tor_free(tmp);
   }
 
@@ -360,7 +360,7 @@ good_bridge_line_test(const char *string, const char *test_addrport,
   if (!test_transport && bridge_line->transport_name)
     tt_assert(0);
   if (test_transport)
-    tt_str_op(test_transport,==, bridge_line->transport_name);
+    tt_str_op(test_transport,OP_EQ, bridge_line->transport_name);
 
   /* Validate the SOCKS argument smartlist. */
   if (test_socks_args && !bridge_line->socks_args)
@@ -839,7 +839,7 @@ test_config_fix_my_family(void *arg)
     TT_FAIL(("options_validate failed: %s", err));
   }
 
-  tt_str_op(options->MyFamily,==, "$1111111111111111111111111111111111111111, "
+  tt_str_op(options->MyFamily,OP_EQ, "$1111111111111111111111111111111111111111, "
                                 "$1111111111111111111111111111111111111112, "
                                 "$1111111111111111111111111111111111111113");
 
diff --git a/src/test/test_containers.c b/src/test/test_containers.c
index d0972dd..89eb1a2 100644
--- a/src/test/test_containers.c
+++ b/src/test/test_containers.c
@@ -62,18 +62,18 @@ test_container_smartlist_basic(void *arg)
   smartlist_insert(sl, 1, v22);
   smartlist_insert(sl, 0, v0);
   smartlist_insert(sl, 5, v555);
-  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));
+  tt_ptr_op(v0,OP_EQ,   smartlist_get(sl,0));
+  tt_ptr_op(v1,OP_EQ,   smartlist_get(sl,1));
+  tt_ptr_op(v22,OP_EQ,  smartlist_get(sl,2));
+  tt_ptr_op(v3,OP_EQ,   smartlist_get(sl,3));
+  tt_ptr_op(v4,OP_EQ,   smartlist_get(sl,4));
+  tt_ptr_op(v555,OP_EQ, smartlist_get(sl,5));
   /* Try deleting in the middle. */
   smartlist_del(sl, 1);
-  tt_ptr_op(v555,==, smartlist_get(sl, 1));
+  tt_ptr_op(v555,OP_EQ, smartlist_get(sl, 1));
   /* Try deleting at the end. */
   smartlist_del(sl, 4);
-  tt_int_op(4,==, smartlist_len(sl));
+  tt_int_op(4,OP_EQ, smartlist_len(sl));
 
   /* test isin. */
   tt_assert(smartlist_contains(sl, v3));
@@ -101,119 +101,119 @@ test_container_smartlist_strings(void *arg)
 
   /* Test split and join */
   (void)arg;
-  tt_int_op(0,==, smartlist_len(sl));
+  tt_int_op(0,OP_EQ, smartlist_len(sl));
   smartlist_split_string(sl, "abc", ":", 0, 0);
-  tt_int_op(1,==, smartlist_len(sl));
-  tt_str_op("abc",==, smartlist_get(sl, 0));
+  tt_int_op(1,OP_EQ, smartlist_len(sl));
+  tt_str_op("abc",OP_EQ, smartlist_get(sl, 0));
   smartlist_split_string(sl, "a::bc::", "::", 0, 0);
-  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));
+  tt_int_op(4,OP_EQ, smartlist_len(sl));
+  tt_str_op("a",OP_EQ, smartlist_get(sl, 1));
+  tt_str_op("bc",OP_EQ, smartlist_get(sl, 2));
+  tt_str_op("",OP_EQ, smartlist_get(sl, 3));
   cp_alloc = smartlist_join_strings(sl, "", 0, NULL);
-  tt_str_op(cp_alloc,==, "abcabc");
+  tt_str_op(cp_alloc,OP_EQ, "abcabc");
   tor_free(cp_alloc);
   cp_alloc = smartlist_join_strings(sl, "!", 0, NULL);
-  tt_str_op(cp_alloc,==, "abc!a!bc!");
+  tt_str_op(cp_alloc,OP_EQ, "abc!a!bc!");
   tor_free(cp_alloc);
   cp_alloc = smartlist_join_strings(sl, "XY", 0, NULL);
-  tt_str_op(cp_alloc,==, "abcXYaXYbcXY");
+  tt_str_op(cp_alloc,OP_EQ, "abcXYaXYbcXY");
   tor_free(cp_alloc);
   cp_alloc = smartlist_join_strings(sl, "XY", 1, NULL);
-  tt_str_op(cp_alloc,==, "abcXYaXYbcXYXY");
+  tt_str_op(cp_alloc,OP_EQ, "abcXYaXYbcXYXY");
   tor_free(cp_alloc);
   cp_alloc = smartlist_join_strings(sl, "", 1, NULL);
-  tt_str_op(cp_alloc,==, "abcabc");
+  tt_str_op(cp_alloc,OP_EQ, "abcabc");
   tor_free(cp_alloc);
 
   smartlist_split_string(sl, "/def/  /ghijk", "/", 0, 0);
-  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));
+  tt_int_op(8,OP_EQ, smartlist_len(sl));
+  tt_str_op("",OP_EQ, smartlist_get(sl, 4));
+  tt_str_op("def",OP_EQ, smartlist_get(sl, 5));
+  tt_str_op("  ",OP_EQ, smartlist_get(sl, 6));
+  tt_str_op("ghijk",OP_EQ, 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);
-  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));
+  tt_int_op(3,OP_EQ, smartlist_len(sl));
+  tt_str_op("a",OP_EQ, smartlist_get(sl,0));
+  tt_str_op("bbd",OP_EQ, smartlist_get(sl,1));
+  tt_str_op("cdef",OP_EQ, smartlist_get(sl,2));
   smartlist_split_string(sl, " z <> zhasd <>  <> bnud<>   ", "<>",
                          SPLIT_SKIP_SPACE, 0);
-  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));
+  tt_int_op(8,OP_EQ, smartlist_len(sl));
+  tt_str_op("z",OP_EQ, smartlist_get(sl,3));
+  tt_str_op("zhasd",OP_EQ, smartlist_get(sl,4));
+  tt_str_op("",OP_EQ, smartlist_get(sl,5));
+  tt_str_op("bnud",OP_EQ, smartlist_get(sl,6));
+  tt_str_op("",OP_EQ, 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);
-  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));
+  tt_int_op(4,OP_EQ, smartlist_len(sl));
+  tt_str_op("ab",OP_EQ, smartlist_get(sl,0));
+  tt_str_op("c",OP_EQ, smartlist_get(sl,1));
+  tt_str_op("d",OP_EQ, smartlist_get(sl,2));
+  tt_str_op("ef",OP_EQ, smartlist_get(sl,3));
   smartlist_split_string(sl, "ghi\tj", NULL,
                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
-  tt_int_op(6,==, smartlist_len(sl));
-  tt_str_op("ghi",==, smartlist_get(sl,4));
-  tt_str_op("j",==, smartlist_get(sl,5));
+  tt_int_op(6,OP_EQ, smartlist_len(sl));
+  tt_str_op("ghi",OP_EQ, smartlist_get(sl,4));
+  tt_str_op("j",OP_EQ, smartlist_get(sl,5));
 
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
 
   cp_alloc = smartlist_join_strings(sl, "XY", 0, NULL);
-  tt_str_op(cp_alloc,==, "");
+  tt_str_op(cp_alloc,OP_EQ, "");
   tor_free(cp_alloc);
   cp_alloc = smartlist_join_strings(sl, "XY", 1, NULL);
-  tt_str_op(cp_alloc,==, "XY");
+  tt_str_op(cp_alloc,OP_EQ, "XY");
   tor_free(cp_alloc);
 
   smartlist_split_string(sl, " z <> zhasd <>  <> bnud<>   ", "<>",
                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
-  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));
+  tt_int_op(3,OP_EQ, smartlist_len(sl));
+  tt_str_op("z",OP_EQ, smartlist_get(sl, 0));
+  tt_str_op("zhasd",OP_EQ, smartlist_get(sl, 1));
+  tt_str_op("bnud",OP_EQ, smartlist_get(sl, 2));
   smartlist_split_string(sl, " z <> zhasd <>  <> bnud<>   ", "<>",
                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 2);
-  tt_int_op(5,==, smartlist_len(sl));
-  tt_str_op("z",==, smartlist_get(sl, 3));
-  tt_str_op("zhasd <>  <> bnud<>",==, smartlist_get(sl, 4));
+  tt_int_op(5,OP_EQ, smartlist_len(sl));
+  tt_str_op("z",OP_EQ, smartlist_get(sl, 3));
+  tt_str_op("zhasd <>  <> bnud<>",OP_EQ, 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);
-  tt_int_op(1,==, smartlist_len(sl));
-  tt_str_op("abcd",==, smartlist_get(sl, 0));
+  tt_int_op(1,OP_EQ, smartlist_len(sl));
+  tt_str_op("abcd",OP_EQ, smartlist_get(sl, 0));
   smartlist_split_string(sl, "efgh", "\n",
                          SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
-  tt_int_op(2,==, smartlist_len(sl));
-  tt_str_op("efgh",==, smartlist_get(sl, 1));
+  tt_int_op(2,OP_EQ, smartlist_len(sl));
+  tt_str_op("efgh",OP_EQ, 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);
-  tt_int_op(7,==, smartlist_len(sl));
+  tt_int_op(7,OP_EQ, smartlist_len(sl));
   smartlist_sort(sl, compare_strs_);
   cp_alloc = smartlist_join_strings(sl, ",", 0, NULL);
-  tt_str_op(cp_alloc,==, "and,arma,by,nickm,onion,router,the");
+  tt_str_op(cp_alloc,OP_EQ, "and,arma,by,nickm,onion,router,the");
   tor_free(cp_alloc);
   smartlist_swap(sl, 1, 5);
   cp_alloc = smartlist_join_strings(sl, ",", 0, NULL);
-  tt_str_op(cp_alloc,==, "and,router,by,nickm,onion,arma,the");
+  tt_str_op(cp_alloc,OP_EQ, "and,router,by,nickm,onion,arma,the");
   tor_free(cp_alloc);
   smartlist_shuffle(sl);
-  tt_int_op(7,==, smartlist_len(sl));
+  tt_int_op(7,OP_EQ, smartlist_len(sl));
   tt_assert(smartlist_contains_string(sl, "and"));
   tt_assert(smartlist_contains_string(sl, "router"));
   tt_assert(smartlist_contains_string(sl, "by"));
@@ -224,69 +224,69 @@ test_container_smartlist_strings(void *arg)
 
   /* Test bsearch. */
   smartlist_sort(sl, compare_strs_);
-  tt_str_op("nickm",==, smartlist_bsearch(sl, "zNicKM",
+  tt_str_op("nickm",OP_EQ, smartlist_bsearch(sl, "zNicKM",
                                         cmp_without_first_));
-  tt_str_op("and",==,
+  tt_str_op("and",OP_EQ,
             smartlist_bsearch(sl, " AND", cmp_without_first_));
-  tt_ptr_op(NULL,==, smartlist_bsearch(sl, " ANz", cmp_without_first_));
+  tt_ptr_op(NULL,OP_EQ, smartlist_bsearch(sl, " ANz", cmp_without_first_));
 
   /* Test bsearch_idx */
   {
     int f;
     smartlist_t *tmp = NULL;
 
-    tt_int_op(0,==,smartlist_bsearch_idx(sl," aaa",cmp_without_first_,&f));
-    tt_int_op(f,==, 0);
-    tt_int_op(0,==, smartlist_bsearch_idx(sl," and",cmp_without_first_,&f));
-    tt_int_op(f,==, 1);
-    tt_int_op(1,==, smartlist_bsearch_idx(sl," arm",cmp_without_first_,&f));
-    tt_int_op(f,==, 0);
-    tt_int_op(1,==, smartlist_bsearch_idx(sl," arma",cmp_without_first_,&f));
-    tt_int_op(f,==, 1);
-    tt_int_op(2,==, smartlist_bsearch_idx(sl," armb",cmp_without_first_,&f));
-    tt_int_op(f,==, 0);
-    tt_int_op(7,==, smartlist_bsearch_idx(sl," zzzz",cmp_without_first_,&f));
-    tt_int_op(f,==, 0);
+    tt_int_op(0,OP_EQ,smartlist_bsearch_idx(sl," aaa",cmp_without_first_,&f));
+    tt_int_op(f,OP_EQ, 0);
+    tt_int_op(0,OP_EQ, smartlist_bsearch_idx(sl," and",cmp_without_first_,&f));
+    tt_int_op(f,OP_EQ, 1);
+    tt_int_op(1,OP_EQ, smartlist_bsearch_idx(sl," arm",cmp_without_first_,&f));
+    tt_int_op(f,OP_EQ, 0);
+    tt_int_op(1,OP_EQ, smartlist_bsearch_idx(sl," arma",cmp_without_first_,&f));
+    tt_int_op(f,OP_EQ, 1);
+    tt_int_op(2,OP_EQ, smartlist_bsearch_idx(sl," armb",cmp_without_first_,&f));
+    tt_int_op(f,OP_EQ, 0);
+    tt_int_op(7,OP_EQ, smartlist_bsearch_idx(sl," zzzz",cmp_without_first_,&f));
+    tt_int_op(f,OP_EQ, 0);
 
     /* Test trivial cases for list of length 0 or 1 */
     tmp = smartlist_new();
-    tt_int_op(0,==, smartlist_bsearch_idx(tmp, "foo",
+    tt_int_op(0,OP_EQ, smartlist_bsearch_idx(tmp, "foo",
                                      compare_strs_for_bsearch_, &f));
-    tt_int_op(f,==, 0);
+    tt_int_op(f,OP_EQ, 0);
     smartlist_insert(tmp, 0, (void *)("bar"));
-    tt_int_op(1,==, smartlist_bsearch_idx(tmp, "foo",
+    tt_int_op(1,OP_EQ, smartlist_bsearch_idx(tmp, "foo",
                                      compare_strs_for_bsearch_, &f));
-    tt_int_op(f,==, 0);
-    tt_int_op(0,==, smartlist_bsearch_idx(tmp, "aaa",
+    tt_int_op(f,OP_EQ, 0);
+    tt_int_op(0,OP_EQ, smartlist_bsearch_idx(tmp, "aaa",
                                      compare_strs_for_bsearch_, &f));
-    tt_int_op(f,==, 0);
-    tt_int_op(0,==, smartlist_bsearch_idx(tmp, "bar",
+    tt_int_op(f,OP_EQ, 0);
+    tt_int_op(0,OP_EQ, smartlist_bsearch_idx(tmp, "bar",
                                      compare_strs_for_bsearch_, &f));
-    tt_int_op(f,==, 1);
+    tt_int_op(f,OP_EQ, 1);
     /* ... and one for length 2 */
     smartlist_insert(tmp, 1, (void *)("foo"));
-    tt_int_op(1,==, smartlist_bsearch_idx(tmp, "foo",
+    tt_int_op(1,OP_EQ, smartlist_bsearch_idx(tmp, "foo",
                                      compare_strs_for_bsearch_, &f));
-    tt_int_op(f,==, 1);
-    tt_int_op(2,==, smartlist_bsearch_idx(tmp, "goo",
+    tt_int_op(f,OP_EQ, 1);
+    tt_int_op(2,OP_EQ, smartlist_bsearch_idx(tmp, "goo",
                                      compare_strs_for_bsearch_, &f));
-    tt_int_op(f,==, 0);
+    tt_int_op(f,OP_EQ, 0);
     smartlist_free(tmp);
   }
 
   /* Test reverse() and pop_last() */
   smartlist_reverse(sl);
   cp_alloc = smartlist_join_strings(sl, ",", 0, NULL);
-  tt_str_op(cp_alloc,==, "the,router,onion,nickm,by,arma,and");
+  tt_str_op(cp_alloc,OP_EQ, "the,router,onion,nickm,by,arma,and");
   tor_free(cp_alloc);
   cp_alloc = smartlist_pop_last(sl);
-  tt_str_op(cp_alloc,==, "and");
+  tt_str_op(cp_alloc,OP_EQ, "and");
   tor_free(cp_alloc);
-  tt_int_op(smartlist_len(sl),==, 6);
+  tt_int_op(smartlist_len(sl),OP_EQ, 6);
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
   cp_alloc = smartlist_pop_last(sl);
-  tt_ptr_op(cp_alloc,==, NULL);
+  tt_ptr_op(cp_alloc,OP_EQ, NULL);
 
   /* Test uniq() */
   smartlist_split_string(sl,
@@ -295,7 +295,7 @@ test_container_smartlist_strings(void *arg)
   smartlist_sort(sl, compare_strs_);
   smartlist_uniq(sl, compare_strs_, tor_free_);
   cp_alloc = smartlist_join_strings(sl, ",", 0, NULL);
-  tt_str_op(cp_alloc,==, "50,a,canal,man,noon,panama,plan,radar");
+  tt_str_op(cp_alloc,OP_EQ, "50,a,canal,man,noon,panama,plan,radar");
   tor_free(cp_alloc);
 
   /* Test contains_string, contains_string_case and contains_int_as_string */
@@ -331,17 +331,17 @@ test_container_smartlist_strings(void *arg)
                     "Some say the Earth will end in ice and some in fire",
                     " ", 0, 0);
   cp = smartlist_get(sl, 4);
-  tt_str_op(cp,==, "will");
+  tt_str_op(cp,OP_EQ, "will");
   smartlist_add(sl, cp);
   smartlist_remove(sl, cp);
   tor_free(cp);
   cp_alloc = smartlist_join_strings(sl, ",", 0, NULL);
-  tt_str_op(cp_alloc,==, "Some,say,the,Earth,fire,end,in,ice,and,some,in");
+  tt_str_op(cp_alloc,OP_EQ, "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);
-  tt_str_op(cp_alloc,==, "Some+say+the+Earth+fire+end+some+ice+and");
-  tt_int_op((int)sz,==, 40);
+  tt_str_op(cp_alloc,OP_EQ, "Some+say+the+Earth+fire+end+some+ice+and");
+  tt_int_op((int)sz,OP_EQ, 40);
 
  done:
 
@@ -369,7 +369,7 @@ test_container_smartlist_overlap(void *arg)
   /* add_all */
   smartlist_add_all(ints, odds);
   smartlist_add_all(ints, evens);
-  tt_int_op(smartlist_len(ints),==, 10);
+  tt_int_op(smartlist_len(ints),OP_EQ, 10);
 
   smartlist_add(primes, (void*)2);
   smartlist_add(primes, (void*)3);
@@ -385,7 +385,7 @@ test_container_smartlist_overlap(void *arg)
   /* intersect */
   smartlist_add_all(sl, odds);
   smartlist_intersect(sl, primes);
-  tt_int_op(smartlist_len(sl),==, 3);
+  tt_int_op(smartlist_len(sl),OP_EQ, 3);
   tt_assert(smartlist_contains(sl, (void*)3));
   tt_assert(smartlist_contains(sl, (void*)5));
   tt_assert(smartlist_contains(sl, (void*)7));
@@ -393,7 +393,7 @@ test_container_smartlist_overlap(void *arg)
   /* subtract */
   smartlist_add_all(sl, primes);
   smartlist_subtract(sl, odds);
-  tt_int_op(smartlist_len(sl),==, 1);
+  tt_int_op(smartlist_len(sl),OP_EQ, 1);
   tt_assert(smartlist_contains(sl, (void*)2));
 
  done:
@@ -415,23 +415,23 @@ test_container_smartlist_digests(void *arg)
   smartlist_add(sl, tor_memdup("AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN));
   smartlist_add(sl, tor_memdup("\00090AAB2AAAAaasdAAAAA", DIGEST_LEN));
   smartlist_add(sl, tor_memdup("\00090AAB2AAAAaasdAAAAA", DIGEST_LEN));
-  tt_int_op(0,==, smartlist_contains_digest(NULL, "AAAAAAAAAAAAAAAAAAAA"));
+  tt_int_op(0,OP_EQ, 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"));
+  tt_int_op(0,OP_EQ, smartlist_contains_digest(sl, "\00090AAB2AAABaasdAAAAA"));
 
   /* sort digests */
   smartlist_sort_digests(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));
+  tt_mem_op(smartlist_get(sl, 0),OP_EQ, "\00090AAB2AAAAaasdAAAAA", DIGEST_LEN);
+  tt_mem_op(smartlist_get(sl, 1),OP_EQ, "\00090AAB2AAAAaasdAAAAA", DIGEST_LEN);
+  tt_mem_op(smartlist_get(sl, 2),OP_EQ, "AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN);
+  tt_int_op(3,OP_EQ, smartlist_len(sl));
 
   /* uniq_digests */
   smartlist_uniq_digests(sl);
-  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);
+  tt_int_op(2,OP_EQ, smartlist_len(sl));
+  tt_mem_op(smartlist_get(sl, 0),OP_EQ, "\00090AAB2AAAAaasdAAAAA", DIGEST_LEN);
+  tt_mem_op(smartlist_get(sl, 1),OP_EQ, "AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN);
 
  done:
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
@@ -463,7 +463,7 @@ test_container_smartlist_join(void *arg)
                          sl2, char *, cp2,
                          strcmp(cp1,cp2),
                          smartlist_add(sl3, cp2)) {
-    tt_str_op(cp1,==, cp2);
+    tt_str_op(cp1,OP_EQ, cp2);
     smartlist_add(sl4, cp1);
   } SMARTLIST_FOREACH_JOIN_END(cp1, cp2);
 
@@ -474,10 +474,10 @@ test_container_smartlist_join(void *arg)
                     tt_assert(smartlist_contains(sl, cp) &&
                                 smartlist_contains_string(sl2, cp)));
   joined = smartlist_join_strings(sl3, ",", 0, NULL);
-  tt_str_op(joined,==, "Anemias,Anemias,Crossbowmen,Work");
+  tt_str_op(joined,OP_EQ, "Anemias,Anemias,Crossbowmen,Work");
   tor_free(joined);
   joined = smartlist_join_strings(sl4, ",", 0, NULL);
-  tt_str_op(joined,==, "Ambush,Anchorman,Anchorman,Bacon,Inhumane,Insurance,"
+  tt_str_op(joined,OP_EQ, "Ambush,Anchorman,Anchorman,Bacon,Inhumane,Insurance,"
              "Knish,Know,Manners,Manners,Maraschinos,Wombats,Wombats");
   tor_free(joined);
 
@@ -612,7 +612,7 @@ test_container_digestset(void *arg)
     if (digestset_contains(set, d))
       ++false_positives;
   }
-  tt_int_op(50, >, false_positives); /* Should be far lower. */
+  tt_int_op(50, OP_GT, false_positives); /* Should be far lower. */
 
  done:
   if (set)
@@ -675,31 +675,31 @@ test_container_pqueue(void *arg)
 
   OK();
 
-  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);
+  tt_int_op(smartlist_len(sl),OP_EQ, 11);
+  tt_ptr_op(smartlist_get(sl, 0),OP_EQ, &apples);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &apples);
+  tt_int_op(smartlist_len(sl),OP_EQ, 10);
   OK();
-  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &cows);
-  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &daschunds);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &cows);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &daschunds);
   smartlist_pqueue_add(sl, cmp, offset, &chinchillas);
   OK();
   smartlist_pqueue_add(sl, cmp, offset, &fireflies);
   OK();
-  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);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &chinchillas);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &eggplants);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &fireflies);
   OK();
-  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);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &fish);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &frogs);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &lobsters);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &roquefort);
   OK();
-  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);
+  tt_int_op(smartlist_len(sl),OP_EQ, 3);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &squid);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &weissbier);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &zebras);
+  tt_int_op(smartlist_len(sl),OP_EQ, 0);
   OK();
 
   /* Now test remove. */
@@ -709,21 +709,21 @@ test_container_pqueue(void *arg)
   smartlist_pqueue_add(sl, cmp, offset, &apples);
   smartlist_pqueue_add(sl, cmp, offset, &squid);
   smartlist_pqueue_add(sl, cmp, offset, &zebras);
-  tt_int_op(smartlist_len(sl),==, 6);
+  tt_int_op(smartlist_len(sl),OP_EQ, 6);
   OK();
   smartlist_pqueue_remove(sl, cmp, offset, &zebras);
-  tt_int_op(smartlist_len(sl),==, 5);
+  tt_int_op(smartlist_len(sl),OP_EQ, 5);
   OK();
   smartlist_pqueue_remove(sl, cmp, offset, &cows);
-  tt_int_op(smartlist_len(sl),==, 4);
+  tt_int_op(smartlist_len(sl),OP_EQ, 4);
   OK();
   smartlist_pqueue_remove(sl, cmp, offset, &apples);
-  tt_int_op(smartlist_len(sl),==, 3);
+  tt_int_op(smartlist_len(sl),OP_EQ, 3);
   OK();
-  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);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &fish);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &frogs);
+  tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &squid);
+  tt_int_op(smartlist_len(sl),OP_EQ, 0);
   OK();
 
 #undef OK
@@ -755,30 +755,30 @@ test_container_strmap(void *arg)
   (void)arg;
   map = strmap_new();
   tt_assert(map);
-  tt_int_op(strmap_size(map),==, 0);
+  tt_int_op(strmap_size(map),OP_EQ, 0);
   tt_assert(strmap_isempty(map));
   v = strmap_set(map, "K1", v99);
-  tt_ptr_op(v,==, NULL);
+  tt_ptr_op(v,OP_EQ, NULL);
   tt_assert(!strmap_isempty(map));
   v = strmap_set(map, "K2", v101);
-  tt_ptr_op(v,==, NULL);
+  tt_ptr_op(v,OP_EQ, NULL);
   v = strmap_set(map, "K1", v100);
-  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);
+  tt_ptr_op(v,OP_EQ, v99);
+  tt_ptr_op(strmap_get(map,"K1"),OP_EQ, v100);
+  tt_ptr_op(strmap_get(map,"K2"),OP_EQ, v101);
+  tt_ptr_op(strmap_get(map,"K-not-there"),OP_EQ, NULL);
   strmap_assert_ok(map);
 
   v = strmap_remove(map,"K2");
   strmap_assert_ok(map);
-  tt_ptr_op(v,==, v101);
-  tt_ptr_op(strmap_get(map,"K2"),==, NULL);
-  tt_ptr_op(strmap_remove(map,"K2"),==, NULL);
+  tt_ptr_op(v,OP_EQ, v101);
+  tt_ptr_op(strmap_get(map,"K2"),OP_EQ, NULL);
+  tt_ptr_op(strmap_remove(map,"K2"),OP_EQ, NULL);
 
   strmap_set(map, "K2", v101);
   strmap_set(map, "K3", v102);
   strmap_set(map, "K4", v103);
-  tt_int_op(strmap_size(map),==, 4);
+  tt_int_op(strmap_size(map),OP_EQ, 4);
   strmap_assert_ok(map);
   strmap_set(map, "K5", v104);
   strmap_set(map, "K6", v105);
@@ -790,7 +790,7 @@ test_container_strmap(void *arg)
   while (!strmap_iter_done(iter)) {
     strmap_iter_get(iter,&k,&v);
     smartlist_add(found_keys, tor_strdup(k));
-    tt_ptr_op(v,==, strmap_get(map, k));
+    tt_ptr_op(v,OP_EQ, strmap_get(map, k));
 
     if (!strcmp(k, "K2")) {
       iter = strmap_iter_next_rmv(map,iter);
@@ -800,12 +800,12 @@ test_container_strmap(void *arg)
   }
 
   /* Make sure we removed K2, but not the others. */
-  tt_ptr_op(strmap_get(map, "K2"),==, NULL);
-  tt_ptr_op(strmap_get(map, "K5"),==, v104);
+  tt_ptr_op(strmap_get(map, "K2"),OP_EQ, NULL);
+  tt_ptr_op(strmap_get(map, "K5"),OP_EQ, v104);
   /* Make sure we visited everyone once */
   smartlist_sort_strings(found_keys);
   visited = smartlist_join_strings(found_keys, ":", 0, NULL);
-  tt_str_op(visited,==, "K1:K2:K3:K4:K5:K6");
+  tt_str_op(visited,OP_EQ, "K1:K2:K3:K4:K5:K6");
 
   strmap_assert_ok(map);
   /* Clean up after ourselves. */
@@ -815,13 +815,13 @@ test_container_strmap(void *arg)
   /* Now try some lc functions. */
   map = strmap_new();
   strmap_set_lc(map,"Ab.C", v1);
-  tt_ptr_op(strmap_get(map,"ab.c"),==, v1);
+  tt_ptr_op(strmap_get(map,"ab.c"),OP_EQ, v1);
   strmap_assert_ok(map);
-  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);
+  tt_ptr_op(strmap_get_lc(map,"AB.C"),OP_EQ, v1);
+  tt_ptr_op(strmap_get(map,"AB.C"),OP_EQ, NULL);
+  tt_ptr_op(strmap_remove_lc(map,"aB.C"),OP_EQ, v1);
   strmap_assert_ok(map);
-  tt_ptr_op(strmap_get_lc(map,"AB.C"),==, NULL);
+  tt_ptr_op(strmap_get_lc(map,"AB.C"),OP_EQ, NULL);
 
  done:
   if (map)
@@ -853,41 +853,41 @@ test_container_order_functions(void *arg)
 
   (void)arg;
   lst[n++] = 12;
-  tt_int_op(12,==, median()); /* 12 */
+  tt_int_op(12,OP_EQ, median()); /* 12 */
   lst[n++] = 77;
   //smartlist_shuffle(sl);
-  tt_int_op(12,==, median()); /* 12, 77 */
+  tt_int_op(12,OP_EQ, median()); /* 12, 77 */
   lst[n++] = 77;
   //smartlist_shuffle(sl);
-  tt_int_op(77,==, median()); /* 12, 77, 77 */
+  tt_int_op(77,OP_EQ, median()); /* 12, 77, 77 */
   lst[n++] = 24;
-  tt_int_op(24,==, median()); /* 12,24,77,77 */
+  tt_int_op(24,OP_EQ, median()); /* 12,24,77,77 */
   lst[n++] = 60;
   lst[n++] = 12;
   lst[n++] = 25;
   //smartlist_shuffle(sl);
-  tt_int_op(25,==, median()); /* 12,12,24,25,60,77,77 */
+  tt_int_op(25,OP_EQ, median()); /* 12,12,24,25,60,77,77 */
 #undef median
 
 #define third_quartile() third_quartile_uint32(lst2, n)
 
   n = 0;
   lst2[n++] = 1;
-  tt_int_op(1,==, third_quartile()); /* ~1~ */
+  tt_int_op(1,OP_EQ, third_quartile()); /* ~1~ */
   lst2[n++] = 2;
-  tt_int_op(2,==, third_quartile()); /* 1, ~2~ */
+  tt_int_op(2,OP_EQ, third_quartile()); /* 1, ~2~ */
   lst2[n++] = 3;
   lst2[n++] = 4;
   lst2[n++] = 5;
-  tt_int_op(4,==, third_quartile()); /* 1, 2, 3, ~4~, 5 */
+  tt_int_op(4,OP_EQ, third_quartile()); /* 1, 2, 3, ~4~, 5 */
   lst2[n++] = 6;
   lst2[n++] = 7;
   lst2[n++] = 8;
   lst2[n++] = 9;
-  tt_int_op(7,==, third_quartile()); /* 1, 2, 3, 4, 5, 6, ~7~, 8, 9 */
+  tt_int_op(7,OP_EQ, third_quartile()); /* 1, 2, 3, 4, 5, 6, ~7~, 8, 9 */
   lst2[n++] = 10;
   lst2[n++] = 11;
-  tt_int_op(9,==, third_quartile()); /* 1, 2, 3, 4, 5, 6, 7, 8, ~9~, 10, 11 */
+  tt_int_op(9,OP_EQ, third_quartile()); /* 1, 2, 3, 4, 5, 6, 7, 8, ~9~, 10, 11 */
 
 #undef third_quartile
 
@@ -911,26 +911,26 @@ test_container_di_map(void *arg)
   (void)arg;
 
   /* Try searching on an empty map. */
-  tt_ptr_op(NULL, ==, dimap_search(map, key1, NULL));
-  tt_ptr_op(NULL, ==, dimap_search(map, key2, NULL));
-  tt_ptr_op(v3, ==, dimap_search(map, key2, v3));
+  tt_ptr_op(NULL, OP_EQ, dimap_search(map, key1, NULL));
+  tt_ptr_op(NULL, OP_EQ, dimap_search(map, key2, NULL));
+  tt_ptr_op(v3, OP_EQ, dimap_search(map, key2, v3));
   dimap_free(map, NULL);
   map = NULL;
 
   /* Add a single entry. */
   dimap_add_entry(&map, key1, v1);
-  tt_ptr_op(NULL, ==, dimap_search(map, key2, NULL));
-  tt_ptr_op(v3, ==, dimap_search(map, key2, v3));
-  tt_ptr_op(v1, ==, dimap_search(map, key1, NULL));
+  tt_ptr_op(NULL, OP_EQ, dimap_search(map, key2, NULL));
+  tt_ptr_op(v3, OP_EQ, dimap_search(map, key2, v3));
+  tt_ptr_op(v1, OP_EQ, dimap_search(map, key1, NULL));
 
   /* Now try it with three entries in the map. */
   dimap_add_entry(&map, key2, v2);
   dimap_add_entry(&map, key3, v3);
-  tt_ptr_op(v1, ==, dimap_search(map, key1, NULL));
-  tt_ptr_op(v2, ==, dimap_search(map, key2, NULL));
-  tt_ptr_op(v3, ==, dimap_search(map, key3, NULL));
-  tt_ptr_op(NULL, ==, dimap_search(map, key4, NULL));
-  tt_ptr_op(v1, ==, dimap_search(map, key4, v1));
+  tt_ptr_op(v1, OP_EQ, dimap_search(map, key1, NULL));
+  tt_ptr_op(v2, OP_EQ, dimap_search(map, key2, NULL));
+  tt_ptr_op(v3, OP_EQ, dimap_search(map, key3, NULL));
+  tt_ptr_op(NULL, OP_EQ, dimap_search(map, key4, NULL));
+  tt_ptr_op(v1, OP_EQ, dimap_search(map, key4, v1));
 
  done:
   tor_free(v1);
@@ -959,7 +959,7 @@ test_container_fp_pair_map(void *arg)
   (void)arg;
   map = fp_pair_map_new();
   tt_assert(map);
-  tt_int_op(fp_pair_map_size(map),==, 0);
+  tt_int_op(fp_pair_map_size(map),OP_EQ, 0);
   tt_assert(fp_pair_map_isempty(map));
 
   memset(fp1.first, 0x11, DIGEST_LEN);
@@ -976,27 +976,27 @@ test_container_fp_pair_map(void *arg)
   memset(fp6.second, 0x62, DIGEST_LEN);
 
   v = fp_pair_map_set(map, &fp1, v99);
-  tt_ptr_op(v, ==, NULL);
+  tt_ptr_op(v, OP_EQ, NULL);
   tt_assert(!fp_pair_map_isempty(map));
   v = fp_pair_map_set(map, &fp2, v101);
-  tt_ptr_op(v, ==, NULL);
+  tt_ptr_op(v, OP_EQ, NULL);
   v = fp_pair_map_set(map, &fp1, v100);
-  tt_ptr_op(v, ==, v99);
-  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);
+  tt_ptr_op(v, OP_EQ, v99);
+  tt_ptr_op(fp_pair_map_get(map, &fp1),OP_EQ, v100);
+  tt_ptr_op(fp_pair_map_get(map, &fp2),OP_EQ, v101);
+  tt_ptr_op(fp_pair_map_get(map, &fp3),OP_EQ, NULL);
   fp_pair_map_assert_ok(map);
 
   v = fp_pair_map_remove(map, &fp2);
   fp_pair_map_assert_ok(map);
-  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);
+  tt_ptr_op(v,OP_EQ, v101);
+  tt_ptr_op(fp_pair_map_get(map, &fp2),OP_EQ, NULL);
+  tt_ptr_op(fp_pair_map_remove(map, &fp2),OP_EQ, NULL);
 
   fp_pair_map_set(map, &fp2, v101);
   fp_pair_map_set(map, &fp3, v102);
   fp_pair_map_set(map, &fp4, v103);
-  tt_int_op(fp_pair_map_size(map),==, 4);
+  tt_int_op(fp_pair_map_size(map),OP_EQ, 4);
   fp_pair_map_assert_ok(map);
   fp_pair_map_set(map, &fp5, v104);
   fp_pair_map_set(map, &fp6, v105);
@@ -1006,7 +1006,7 @@ test_container_fp_pair_map(void *arg)
   iter = fp_pair_map_iter_init(map);
   while (!fp_pair_map_iter_done(iter)) {
     fp_pair_map_iter_get(iter, &k, &v);
-    tt_ptr_op(v,==, fp_pair_map_get(map, &k));
+    tt_ptr_op(v,OP_EQ, fp_pair_map_get(map, &k));
 
     if (tor_memeq(&fp2, &k, sizeof(fp2))) {
       iter = fp_pair_map_iter_next_rmv(map, iter);
@@ -1016,8 +1016,8 @@ test_container_fp_pair_map(void *arg)
   }
 
   /* Make sure we removed fp2, but not the others. */
-  tt_ptr_op(fp_pair_map_get(map, &fp2),==, NULL);
-  tt_ptr_op(fp_pair_map_get(map, &fp5),==, v104);
+  tt_ptr_op(fp_pair_map_get(map, &fp2),OP_EQ, NULL);
+  tt_ptr_op(fp_pair_map_get(map, &fp5),OP_EQ, v104);
 
   fp_pair_map_assert_ok(map);
   /* Clean up after ourselves. */
diff --git a/src/test/test_controller_events.c b/src/test/test_controller_events.c
index 4d6077b..dd9d590 100644
--- a/src/test/test_controller_events.c
+++ b/src/test/test_controller_events.c
@@ -22,7 +22,7 @@ help_test_bucket_note_empty(uint32_t expected_msec_since_midnight,
   tvnow.tv_usec = (msec_since_epoch % 1000) * 1000;
   connection_buckets_note_empty_ts(&timestamp_var, tokens_before,
                                    tokens_removed, &tvnow);
-  tt_int_op(expected_msec_since_midnight, ==, timestamp_var);
+  tt_int_op(expected_msec_since_midnight, OP_EQ, timestamp_var);
 
  done:
   ;
@@ -57,20 +57,20 @@ test_cntev_bucket_millis_empty(void *arg)
   tvnow.tv_usec = 200000;
 
   /* Bucket has not been refilled. */
-  tt_int_op(0, ==, bucket_millis_empty(0, 42120, 0, 100, &tvnow));
-  tt_int_op(0, ==, bucket_millis_empty(-10, 42120, -10, 100, &tvnow));
+  tt_int_op(0, OP_EQ, bucket_millis_empty(0, 42120, 0, 100, &tvnow));
+  tt_int_op(0, OP_EQ, bucket_millis_empty(-10, 42120, -10, 100, &tvnow));
 
   /* Bucket was not empty. */
-  tt_int_op(0, ==, bucket_millis_empty(10, 42120, 20, 100, &tvnow));
+  tt_int_op(0, OP_EQ, bucket_millis_empty(10, 42120, 20, 100, &tvnow));
 
   /* Bucket has been emptied 80 msec ago and has just been refilled. */
-  tt_int_op(80, ==, bucket_millis_empty(-20, 42120, -10, 100, &tvnow));
-  tt_int_op(80, ==, bucket_millis_empty(-10, 42120, 0, 100, &tvnow));
-  tt_int_op(80, ==, bucket_millis_empty(0, 42120, 10, 100, &tvnow));
+  tt_int_op(80, OP_EQ, bucket_millis_empty(-20, 42120, -10, 100, &tvnow));
+  tt_int_op(80, OP_EQ, bucket_millis_empty(-10, 42120, 0, 100, &tvnow));
+  tt_int_op(80, OP_EQ, bucket_millis_empty(0, 42120, 10, 100, &tvnow));
 
   /* Bucket has been emptied 180 msec ago, last refill was 100 msec ago
    * which was insufficient to make it positive, so cap msec at 100. */
-  tt_int_op(100, ==, bucket_millis_empty(0, 42020, 1, 100, &tvnow));
+  tt_int_op(100, OP_EQ, bucket_millis_empty(0, 42020, 1, 100, &tvnow));
 
   /* 1970-01-02 00:00:00:050000 */
   tvnow.tv_sec = 86400;
@@ -78,7 +78,7 @@ test_cntev_bucket_millis_empty(void *arg)
 
   /* Last emptied 30 msec before midnight, tvnow is 50 msec after
    * midnight, that's 80 msec in total. */
-  tt_int_op(80, ==, bucket_millis_empty(0, 86400000 - 30, 1, 100, &tvnow));
+  tt_int_op(80, OP_EQ, bucket_millis_empty(0, 86400000 - 30, 1, 100, &tvnow));
 
  done:
   ;
@@ -118,26 +118,26 @@ test_cntev_sum_up_cell_stats(void *arg)
   cell_stats = tor_malloc_zero(sizeof(cell_stats_t));
   add_testing_cell_stats_entry(circ, CELL_RELAY, 0, 0, 0);
   sum_up_cell_stats_by_command(circ, cell_stats);
-  tt_u64_op(1, ==, cell_stats->added_cells_appward[CELL_RELAY]);
+  tt_u64_op(1, OP_EQ, cell_stats->added_cells_appward[CELL_RELAY]);
 
   /* A single RELAY cell was added to the exitward queue. */
   add_testing_cell_stats_entry(circ, CELL_RELAY, 0, 0, 1);
   sum_up_cell_stats_by_command(circ, cell_stats);
-  tt_u64_op(1, ==, cell_stats->added_cells_exitward[CELL_RELAY]);
+  tt_u64_op(1, OP_EQ, cell_stats->added_cells_exitward[CELL_RELAY]);
 
   /* A single RELAY cell was removed from the appward queue where it spent
    * 20 msec. */
   add_testing_cell_stats_entry(circ, CELL_RELAY, 2, 1, 0);
   sum_up_cell_stats_by_command(circ, cell_stats);
-  tt_u64_op(20, ==, cell_stats->total_time_appward[CELL_RELAY]);
-  tt_u64_op(1, ==, cell_stats->removed_cells_appward[CELL_RELAY]);
+  tt_u64_op(20, OP_EQ, cell_stats->total_time_appward[CELL_RELAY]);
+  tt_u64_op(1, OP_EQ, cell_stats->removed_cells_appward[CELL_RELAY]);
 
   /* A single RELAY cell was removed from the exitward queue where it
    * spent 30 msec. */
   add_testing_cell_stats_entry(circ, CELL_RELAY, 3, 1, 1);
   sum_up_cell_stats_by_command(circ, cell_stats);
-  tt_u64_op(30, ==, cell_stats->total_time_exitward[CELL_RELAY]);
-  tt_u64_op(1, ==, cell_stats->removed_cells_exitward[CELL_RELAY]);
+  tt_u64_op(30, OP_EQ, cell_stats->total_time_exitward[CELL_RELAY]);
+  tt_u64_op(1, OP_EQ, cell_stats->removed_cells_exitward[CELL_RELAY]);
 
  done:
   tor_free(cell_stats);
@@ -164,7 +164,7 @@ test_cntev_append_cell_stats(void *arg)
   append_cell_stats_by_command(event_parts, key,
                                include_if_non_zero,
                                number_to_include);
-  tt_int_op(0, ==, smartlist_len(event_parts));
+  tt_int_op(0, OP_EQ, smartlist_len(event_parts));
 
   /* There's a RELAY cell to include, but the corresponding field in
    * include_if_non_zero is still zero. */
@@ -172,7 +172,7 @@ test_cntev_append_cell_stats(void *arg)
   append_cell_stats_by_command(event_parts, key,
                                include_if_non_zero,
                                number_to_include);
-  tt_int_op(0, ==, smartlist_len(event_parts));
+  tt_int_op(0, OP_EQ, smartlist_len(event_parts));
 
   /* Now include single RELAY cell. */
   include_if_non_zero[CELL_RELAY] = 2;
@@ -180,7 +180,7 @@ test_cntev_append_cell_stats(void *arg)
                                include_if_non_zero,
                                number_to_include);
   cp = smartlist_pop_last(event_parts);
-  tt_str_op("Z=relay:1", ==, cp);
+  tt_str_op("Z=relay:1", OP_EQ, cp);
   tor_free(cp);
 
   /* Add four CREATE cells. */
@@ -190,7 +190,7 @@ test_cntev_append_cell_stats(void *arg)
                                include_if_non_zero,
                                number_to_include);
   cp = smartlist_pop_last(event_parts);
-  tt_str_op("Z=create:4,relay:1", ==, cp);
+  tt_str_op("Z=create:4,relay:1", OP_EQ, cp);
 
  done:
   tor_free(cp);
@@ -220,14 +220,14 @@ test_cntev_format_cell_stats(void *arg)
   /* Origin circuit was completely idle. */
   cell_stats = tor_malloc_zero(sizeof(cell_stats_t));
   format_cell_stats(&event_string, TO_CIRCUIT(ocirc), cell_stats);
-  tt_str_op("ID=2 OutboundQueue=3 OutboundConn=1", ==, event_string);
+  tt_str_op("ID=2 OutboundQueue=3 OutboundConn=1", OP_EQ, event_string);
   tor_free(event_string);
 
   /* Origin circuit had 4 RELAY cells added to its exitward queue. */
   cell_stats->added_cells_exitward[CELL_RELAY] = 4;
   format_cell_stats(&event_string, TO_CIRCUIT(ocirc), cell_stats);
   tt_str_op("ID=2 OutboundQueue=3 OutboundConn=1 OutboundAdded=relay:4",
-            ==, event_string);
+            OP_EQ, event_string);
   tor_free(event_string);
 
   /* Origin circuit also had 5 CREATE2 cells added to its exitward
@@ -235,7 +235,7 @@ test_cntev_format_cell_stats(void *arg)
   cell_stats->added_cells_exitward[CELL_CREATE2] = 5;
   format_cell_stats(&event_string, TO_CIRCUIT(ocirc), cell_stats);
   tt_str_op("ID=2 OutboundQueue=3 OutboundConn=1 OutboundAdded=relay:4,"
-            "create2:5", ==, event_string);
+            "create2:5", OP_EQ, event_string);
   tor_free(event_string);
 
   /* Origin circuit also had 7 RELAY cells removed from its exitward queue
@@ -245,7 +245,7 @@ test_cntev_format_cell_stats(void *arg)
   format_cell_stats(&event_string, TO_CIRCUIT(ocirc), cell_stats);
   tt_str_op("ID=2 OutboundQueue=3 OutboundConn=1 OutboundAdded=relay:4,"
             "create2:5 OutboundRemoved=relay:7 OutboundTime=relay:6",
-            ==, event_string);
+            OP_EQ, event_string);
   tor_free(event_string);
 
   p_chan = tor_malloc_zero(sizeof(channel_tls_t));
@@ -265,14 +265,14 @@ test_cntev_format_cell_stats(void *arg)
   cell_stats = tor_malloc_zero(sizeof(cell_stats_t));
   format_cell_stats(&event_string, TO_CIRCUIT(or_circ), cell_stats);
   tt_str_op("InboundQueue=8 InboundConn=2 OutboundQueue=9 OutboundConn=1",
-            ==, event_string);
+            OP_EQ, event_string);
   tor_free(event_string);
 
   /* OR circuit had 3 RELAY cells added to its appward queue. */
   cell_stats->added_cells_appward[CELL_RELAY] = 3;
   format_cell_stats(&event_string, TO_CIRCUIT(or_circ), cell_stats);
   tt_str_op("InboundQueue=8 InboundConn=2 InboundAdded=relay:3 "
-            "OutboundQueue=9 OutboundConn=1", ==, event_string);
+            "OutboundQueue=9 OutboundConn=1", OP_EQ, event_string);
   tor_free(event_string);
 
   /* OR circuit had 7 RELAY cells removed from its appward queue which
@@ -282,7 +282,7 @@ test_cntev_format_cell_stats(void *arg)
   format_cell_stats(&event_string, TO_CIRCUIT(or_circ), cell_stats);
   tt_str_op("InboundQueue=8 InboundConn=2 InboundAdded=relay:3 "
             "InboundRemoved=relay:7 InboundTime=relay:6 "
-            "OutboundQueue=9 OutboundConn=1", ==, event_string);
+            "OutboundQueue=9 OutboundConn=1", OP_EQ, event_string);
 
  done:
   tor_free(cell_stats);
diff --git a/src/test/test_crypto.c b/src/test/test_crypto.c
index 4416134..d3cd013 100644
--- a/src/test/test_crypto.c
+++ b/src/test/test_crypto.c
@@ -34,24 +34,24 @@ test_crypto_dh(void *arg)
   ssize_t s1len, s2len;
 
   (void)arg;
-  tt_int_op(crypto_dh_get_bytes(dh1),==, DH_BYTES);
-  tt_int_op(crypto_dh_get_bytes(dh2),==, DH_BYTES);
+  tt_int_op(crypto_dh_get_bytes(dh1),OP_EQ, DH_BYTES);
+  tt_int_op(crypto_dh_get_bytes(dh2),OP_EQ, DH_BYTES);
 
   memset(p1, 0, DH_BYTES);
   memset(p2, 0, DH_BYTES);
-  tt_mem_op(p1,==, p2, DH_BYTES);
+  tt_mem_op(p1,OP_EQ, p2, DH_BYTES);
   tt_assert(! crypto_dh_get_public(dh1, p1, DH_BYTES));
-  tt_mem_op(p1,!=, p2, DH_BYTES);
+  tt_mem_op(p1,OP_NE, p2, DH_BYTES);
   tt_assert(! crypto_dh_get_public(dh2, p2, DH_BYTES));
-  tt_mem_op(p1,!=, p2, DH_BYTES);
+  tt_mem_op(p1,OP_NE, 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);
   tt_assert(s1len > 0);
-  tt_int_op(s1len,==, s2len);
-  tt_mem_op(s1,==, s2, s1len);
+  tt_int_op(s1len,OP_EQ, s2len);
+  tt_mem_op(s1,OP_EQ, s2, s1len);
 
   {
     /* XXXX Now fabricate some bad values and make sure they get caught,
@@ -78,7 +78,7 @@ test_crypto_rng(void *arg)
   tt_assert(! crypto_seed_rng(0));
   crypto_rand(data1, 100);
   crypto_rand(data2, 100);
-  tt_mem_op(data1,!=, data2,100);
+  tt_mem_op(data1,OP_NE, data2,100);
   allok = 1;
   for (i = 0; i < 100; ++i) {
     uint64_t big;
@@ -133,15 +133,15 @@ test_crypto_aes(void *arg)
   memset(data2, 0, 1024);
   memset(data3, 0, 1024);
   env1 = crypto_cipher_new(NULL);
-  tt_ptr_op(env1, !=, NULL);
+  tt_ptr_op(env1, OP_NE, NULL);
   env2 = crypto_cipher_new(crypto_cipher_get_key(env1));
-  tt_ptr_op(env2, !=, NULL);
+  tt_ptr_op(env2, OP_NE, NULL);
 
   /* Try encrypting 512 chars. */
   crypto_cipher_encrypt(env1, data2, data1, 512);
   crypto_cipher_decrypt(env2, data3, data2, 512);
-  tt_mem_op(data1,==, data3, 512);
-  tt_mem_op(data1,!=, data2, 512);
+  tt_mem_op(data1,OP_EQ, data3, 512);
+  tt_mem_op(data1,OP_NE, data2, 512);
 
   /* Now encrypt 1 at a time, and get 1 at a time. */
   for (j = 512; j < 560; ++j) {
@@ -150,7 +150,7 @@ test_crypto_aes(void *arg)
   for (j = 512; j < 560; ++j) {
     crypto_cipher_decrypt(env2, data3+j, data2+j, 1);
   }
-  tt_mem_op(data1,==, data3, 560);
+  tt_mem_op(data1,OP_EQ, 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);
@@ -158,7 +158,7 @@ test_crypto_aes(void *arg)
   for (j = 560; j < 1024-5; j += 5) {
     crypto_cipher_decrypt(env2, data3+j, data2+j, 5);
   }
-  tt_mem_op(data1,==, data3, 1024-5);
+  tt_mem_op(data1,OP_EQ, data3, 1024-5);
   /* Now make sure that when we encrypt with different chunk sizes, we get
      the same results. */
   crypto_cipher_free(env2);
@@ -166,7 +166,7 @@ test_crypto_aes(void *arg)
 
   memset(data3, 0, 1024);
   env2 = crypto_cipher_new(crypto_cipher_get_key(env1));
-  tt_ptr_op(env2, !=, NULL);
+  tt_ptr_op(env2, OP_NE, NULL);
   for (j = 0; j < 1024-16; j += 17) {
     crypto_cipher_encrypt(env2, data3+j, data1+j, 17);
   }
@@ -175,7 +175,7 @@ test_crypto_aes(void *arg)
       printf("%d:  %d\t%d\n", j, (int) data2[j], (int) data3[j]);
     }
   }
-  tt_mem_op(data2,==, data3, 1024-16);
+  tt_mem_op(data2,OP_EQ, data3, 1024-16);
   crypto_cipher_free(env1);
   env1 = NULL;
   crypto_cipher_free(env2);
@@ -271,25 +271,25 @@ test_crypto_sha(void *arg)
   (void)arg;
   i = crypto_digest(data, "abc", 3);
   test_memeq_hex(data, "A9993E364706816ABA3E25717850C26C9CD0D89D");
-  tt_int_op(i, ==, 0);
+  tt_int_op(i, OP_EQ, 0);
 
   /* Test SHA-256 with a test vector from the specification. */
   i = crypto_digest256(data, "abc", 3, DIGEST_SHA256);
   test_memeq_hex(data, "BA7816BF8F01CFEA414140DE5DAE2223B00361A3"
                        "96177A9CB410FF61F20015AD");
-  tt_int_op(i, ==, 0);
+  tt_int_op(i, OP_EQ, 0);
 
   /* Test HMAC-SHA256 with test cases from wikipedia and RFC 4231 */
 
   /* Case empty (wikipedia) */
   crypto_hmac_sha256(digest, "", 0, "", 0);
-  tt_str_op(hex_str(digest, 32),==,
+  tt_str_op(hex_str(digest, 32),OP_EQ,
            "B613679A0814D9EC772F95D778C35FC5FF1697C493715653C6C712144292C5AD");
 
   /* Case quick-brown (wikipedia) */
   crypto_hmac_sha256(digest, "key", 3,
                      "The quick brown fox jumps over the lazy dog", 43);
-  tt_str_op(hex_str(digest, 32),==,
+  tt_str_op(hex_str(digest, 32),OP_EQ,
            "F7BC83F430538424B13298E6AA6FB143EF4D59A14946175997479DBC2D1A3CD8");
 
   /* "Test Case 1" from RFC 4231 */
@@ -357,15 +357,15 @@ test_crypto_sha(void *arg)
   crypto_digest_add_bytes(d2, "ghijkl", 6);
   crypto_digest_get_digest(d2, d_out1, sizeof(d_out1));
   crypto_digest(d_out2, "abcdefghijkl", 12);
-  tt_mem_op(d_out1,==, d_out2, DIGEST_LEN);
+  tt_mem_op(d_out1,OP_EQ, 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);
-  tt_mem_op(d_out1,==, d_out2, DIGEST_LEN);
+  tt_mem_op(d_out1,OP_EQ, d_out2, DIGEST_LEN);
   crypto_digest_get_digest(d1, d_out1, sizeof(d_out1));
   crypto_digest(d_out2, "abcdef", 6);
-  tt_mem_op(d_out1,==, d_out2, DIGEST_LEN);
+  tt_mem_op(d_out1,OP_EQ, d_out2, DIGEST_LEN);
   crypto_digest_free(d1);
   crypto_digest_free(d2);
 
@@ -378,15 +378,15 @@ test_crypto_sha(void *arg)
   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);
-  tt_mem_op(d_out1,==, d_out2, DIGEST_LEN);
+  tt_mem_op(d_out1,OP_EQ, 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);
-  tt_mem_op(d_out1,==, d_out2, DIGEST_LEN);
+  tt_mem_op(d_out1,OP_EQ, d_out2, DIGEST_LEN);
   crypto_digest_get_digest(d1, d_out1, sizeof(d_out1));
   crypto_digest256(d_out2, "abcdef", 6, DIGEST_SHA256);
-  tt_mem_op(d_out1,==, d_out2, DIGEST_LEN);
+  tt_mem_op(d_out1,OP_EQ, d_out2, DIGEST_LEN);
 
  done:
   if (d1)
@@ -413,42 +413,42 @@ test_crypto_pk(void *arg)
   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));
+  tt_int_op(0,OP_EQ, 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);
+  tt_int_op(crypto_pk_cmp_keys(NULL, pk1), OP_LT, 0);
+  tt_int_op(crypto_pk_cmp_keys(NULL, NULL), OP_EQ, 0);
+  tt_int_op(crypto_pk_cmp_keys(pk1, NULL), OP_GT, 0);
 
-  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));
+  tt_int_op(128,OP_EQ, crypto_pk_keysize(pk1));
+  tt_int_op(1024,OP_EQ, crypto_pk_num_bits(pk1));
+  tt_int_op(128,OP_EQ, crypto_pk_keysize(pk2));
+  tt_int_op(1024,OP_EQ, crypto_pk_num_bits(pk2));
 
-  tt_int_op(128,==, crypto_pk_public_encrypt(pk2, data1, sizeof(data1),
+  tt_int_op(128,OP_EQ, crypto_pk_public_encrypt(pk2, data1, sizeof(data1),
                                         "Hello whirled.", 15,
                                         PK_PKCS1_OAEP_PADDING));
-  tt_int_op(128,==, crypto_pk_public_encrypt(pk1, data2, sizeof(data1),
+  tt_int_op(128,OP_EQ, crypto_pk_public_encrypt(pk1, data2, sizeof(data1),
                                         "Hello whirled.", 15,
                                         PK_PKCS1_OAEP_PADDING));
   /* oaep padding should make encryption not match */
-  tt_mem_op(data1,!=, data2, 128);
-  tt_int_op(15,==,
+  tt_mem_op(data1,OP_NE, data2, 128);
+  tt_int_op(15,OP_EQ,
             crypto_pk_private_decrypt(pk1, data3, sizeof(data3), data1, 128,
                                         PK_PKCS1_OAEP_PADDING,1));
-  tt_str_op(data3,==, "Hello whirled.");
+  tt_str_op(data3,OP_EQ, "Hello whirled.");
   memset(data3, 0, 1024);
-  tt_int_op(15,==,
+  tt_int_op(15,OP_EQ,
             crypto_pk_private_decrypt(pk1, data3, sizeof(data3), data2, 128,
                                         PK_PKCS1_OAEP_PADDING,1));
-  tt_str_op(data3,==, "Hello whirled.");
+  tt_str_op(data3,OP_EQ, "Hello whirled.");
   /* Can't decrypt with public key. */
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             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 */
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             crypto_pk_private_decrypt(pk1, data3, sizeof(data3), data2, 128,
                                         PK_PKCS1_OAEP_PADDING,1));
 
@@ -464,25 +464,25 @@ test_crypto_pk(void *arg)
                                                    get_fname("xyzzy")) < 0);
   tt_assert(! crypto_pk_read_private_key_from_filename(pk2,
                                                          get_fname("pkey1")));
-  tt_int_op(15,==,
+  tt_int_op(15,OP_EQ,
             crypto_pk_private_decrypt(pk2, data3, sizeof(data3), data1, 128,
                                         PK_PKCS1_OAEP_PADDING,1));
 
   /* Now try signing. */
   strlcpy(data1, "Ossifrage", 1024);
-  tt_int_op(128,==,
+  tt_int_op(128,OP_EQ,
             crypto_pk_private_sign(pk1, data2, sizeof(data2), data1, 10));
-  tt_int_op(10,==,
+  tt_int_op(10,OP_EQ,
           crypto_pk_public_checksig(pk1, data3, sizeof(data3), data2, 128));
-  tt_str_op(data3,==, "Ossifrage");
+  tt_str_op(data3,OP_EQ, "Ossifrage");
   /* Try signing digests. */
-  tt_int_op(128,==, crypto_pk_private_sign_digest(pk1, data2, sizeof(data2),
+  tt_int_op(128,OP_EQ, crypto_pk_private_sign_digest(pk1, data2, sizeof(data2),
                                              data1, 10));
-  tt_int_op(20,==,
+  tt_int_op(20,OP_EQ,
           crypto_pk_public_checksig(pk1, data3, sizeof(data3), data2, 128));
-  tt_int_op(0,==,
+  tt_int_op(0,OP_EQ,
             crypto_pk_public_checksig_digest(pk1, data1, 10, data2, 128));
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             crypto_pk_public_checksig_digest(pk1, data1, 11, data2, 128));
 
   /*XXXX test failed signing*/
@@ -491,7 +491,7 @@ test_crypto_pk(void *arg)
   crypto_pk_free(pk2);
   pk2 = NULL;
   i = crypto_pk_asn1_encode(pk1, data1, 1024);
-  tt_int_op(i, >, 0);
+  tt_int_op(i, OP_GT, 0);
   pk2 = crypto_pk_asn1_decode(data1, i);
   tt_assert(crypto_pk_cmp_keys(pk1,pk2) == 0);
 
@@ -502,18 +502,18 @@ test_crypto_pk(void *arg)
     memset(data3,0,1024);
     len = crypto_pk_public_hybrid_encrypt(pk1,data2,sizeof(data2),
                                           data1,i,PK_PKCS1_OAEP_PADDING,0);
-    tt_int_op(len, >=, 0);
+    tt_int_op(len, OP_GE, 0);
     len = crypto_pk_private_hybrid_decrypt(pk1,data3,sizeof(data3),
                                            data2,len,PK_PKCS1_OAEP_PADDING,1);
-    tt_int_op(len,==, i);
-    tt_mem_op(data1,==, data3,i);
+    tt_int_op(len,OP_EQ, i);
+    tt_mem_op(data1,OP_EQ, data3,i);
   }
 
   /* Try copy_full */
   crypto_pk_free(pk2);
   pk2 = crypto_pk_copy_full(pk1);
   tt_assert(pk2 != NULL);
-  tt_ptr_op(pk1, !=, pk2);
+  tt_ptr_op(pk1, OP_NE, pk2);
   tt_assert(crypto_pk_cmp_keys(pk1,pk2) == 0);
 
  done:
@@ -540,33 +540,33 @@ test_crypto_pk_fingerprints(void *arg)
   pk = pk_generate(1);
   tt_assert(pk);
   n = crypto_pk_asn1_encode(pk, encoded, sizeof(encoded));
-  tt_int_op(n, >, 0);
-  tt_int_op(n, >, 128);
-  tt_int_op(n, <, 256);
+  tt_int_op(n, OP_GT, 0);
+  tt_int_op(n, OP_GT, 128);
+  tt_int_op(n, OP_LT, 256);
 
   /* Is digest as expected? */
   crypto_digest(d, encoded, n);
-  tt_int_op(0, ==, crypto_pk_get_digest(pk, d2));
-  tt_mem_op(d,==, d2, DIGEST_LEN);
+  tt_int_op(0, OP_EQ, crypto_pk_get_digest(pk, d2));
+  tt_mem_op(d,OP_EQ, d2, DIGEST_LEN);
 
   /* Is fingerprint right? */
-  tt_int_op(0, ==, crypto_pk_get_fingerprint(pk, fingerprint, 0));
-  tt_int_op(strlen(fingerprint), ==, DIGEST_LEN * 2);
+  tt_int_op(0, OP_EQ, crypto_pk_get_fingerprint(pk, fingerprint, 0));
+  tt_int_op(strlen(fingerprint), OP_EQ, DIGEST_LEN * 2);
   test_memeq_hex(d, fingerprint);
 
   /* Are spaces right? */
-  tt_int_op(0, ==, crypto_pk_get_fingerprint(pk, fingerprint, 1));
+  tt_int_op(0, OP_EQ, crypto_pk_get_fingerprint(pk, fingerprint, 1));
   for (i = 4; i < strlen(fingerprint); i += 5) {
-    tt_int_op(fingerprint[i], ==, ' ');
+    tt_int_op(fingerprint[i], OP_EQ, ' ');
   }
   tor_strstrip(fingerprint, " ");
-  tt_int_op(strlen(fingerprint), ==, DIGEST_LEN * 2);
+  tt_int_op(strlen(fingerprint), OP_EQ, DIGEST_LEN * 2);
   test_memeq_hex(d, fingerprint);
 
   /* Now hash again and check crypto_pk_get_hashed_fingerprint. */
   crypto_digest(d2, d, sizeof(d));
-  tt_int_op(0, ==, crypto_pk_get_hashed_fingerprint(pk, fingerprint));
-  tt_int_op(strlen(fingerprint), ==, DIGEST_LEN * 2);
+  tt_int_op(0, OP_EQ, crypto_pk_get_hashed_fingerprint(pk, fingerprint));
+  tt_int_op(strlen(fingerprint), OP_EQ, DIGEST_LEN * 2);
   test_memeq_hex(d2, fingerprint);
 
  done:
@@ -591,14 +591,14 @@ test_crypto_digests(void *arg)
 
   r = crypto_pk_get_digest(k, digest);
   tt_assert(r == 0);
-  tt_mem_op(hex_str(digest, DIGEST_LEN),==,
+  tt_mem_op(hex_str(digest, DIGEST_LEN),OP_EQ,
              AUTHORITY_SIGNKEY_A_DIGEST, HEX_DIGEST_LEN);
 
   r = crypto_pk_get_all_digests(k, &pkey_digests);
 
-  tt_mem_op(hex_str(pkey_digests.d[DIGEST_SHA1], DIGEST_LEN),==,
+  tt_mem_op(hex_str(pkey_digests.d[DIGEST_SHA1], DIGEST_LEN),OP_EQ,
              AUTHORITY_SIGNKEY_A_DIGEST, HEX_DIGEST_LEN);
-  tt_mem_op(hex_str(pkey_digests.d[DIGEST_SHA256], DIGEST256_LEN),==,
+  tt_mem_op(hex_str(pkey_digests.d[DIGEST_SHA256], DIGEST256_LEN),OP_EQ,
              AUTHORITY_SIGNKEY_A_DIGEST256, HEX_DIGEST256_LEN);
  done:
   crypto_pk_free(k);
@@ -622,31 +622,31 @@ test_crypto_formats(void *arg)
   memset(data1, 6, 1024);
   for (idx = 0; idx < 10; ++idx) {
     i = base64_encode(data2, 1024, data1, idx);
-    tt_int_op(i, >=, 0);
+    tt_int_op(i, OP_GE, 0);
     j = base64_decode(data3, 1024, data2, i);
-    tt_int_op(j,==, idx);
-    tt_mem_op(data3,==, data1, idx);
+    tt_int_op(j,OP_EQ, idx);
+    tt_mem_op(data3,OP_EQ, 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);
-  tt_int_op(i, >=, 0);
+  tt_int_op(i, OP_GE, 0);
   j = base64_decode(data3, 1024, data2, i);
-  tt_int_op(j,==, 71);
-  tt_str_op(data3,==, data1);
-  tt_int_op(data2[i], ==, '\0');
+  tt_int_op(j,OP_EQ, 71);
+  tt_str_op(data3,OP_EQ, data1);
+  tt_int_op(data2[i], OP_EQ, '\0');
 
   crypto_rand(data1, DIGEST_LEN);
   memset(data2, 100, 1024);
   digest_to_base64(data2, data1);
-  tt_int_op(BASE64_DIGEST_LEN,==, strlen(data2));
-  tt_int_op(100,==, data2[BASE64_DIGEST_LEN+2]);
+  tt_int_op(BASE64_DIGEST_LEN,OP_EQ, strlen(data2));
+  tt_int_op(100,OP_EQ, data2[BASE64_DIGEST_LEN+2]);
   memset(data3, 99, 1024);
-  tt_int_op(digest_from_base64(data3, data2),==, 0);
-  tt_mem_op(data1,==, data3, DIGEST_LEN);
-  tt_int_op(99,==, data3[DIGEST_LEN+1]);
+  tt_int_op(digest_from_base64(data3, data2),OP_EQ, 0);
+  tt_mem_op(data1,OP_EQ, data3, DIGEST_LEN);
+  tt_int_op(99,OP_EQ, data3[DIGEST_LEN+1]);
 
   tt_assert(digest_from_base64(data3, "###") < 0);
 
@@ -654,12 +654,12 @@ test_crypto_formats(void *arg)
   crypto_rand(data2, DIGEST256_LEN);
   memset(data2, 100, 1024);
   digest256_to_base64(data2, data1);
-  tt_int_op(BASE64_DIGEST256_LEN,==, strlen(data2));
-  tt_int_op(100,==, data2[BASE64_DIGEST256_LEN+2]);
+  tt_int_op(BASE64_DIGEST256_LEN,OP_EQ, strlen(data2));
+  tt_int_op(100,OP_EQ, data2[BASE64_DIGEST256_LEN+2]);
   memset(data3, 99, 1024);
-  tt_int_op(digest256_from_base64(data3, data2),==, 0);
-  tt_mem_op(data1,==, data3, DIGEST256_LEN);
-  tt_int_op(99,==, data3[DIGEST256_LEN+1]);
+  tt_int_op(digest256_from_base64(data3, data2),OP_EQ, 0);
+  tt_mem_op(data1,OP_EQ, data3, DIGEST256_LEN);
+  tt_int_op(99,OP_EQ, data3[DIGEST256_LEN+1]);
 
   /* Base32 tests */
   strlcpy(data1, "5chrs", 1024);
@@ -668,27 +668,27 @@ test_crypto_formats(void *arg)
    * By 5s: [00110 10101 10001 10110 10000 11100 10011 10011]
    */
   base32_encode(data2, 9, data1, 5);
-  tt_str_op(data2,==, "gvrwq4tt");
+  tt_str_op(data2,OP_EQ, "gvrwq4tt");
 
   strlcpy(data1, "\xFF\xF5\x6D\x44\xAE\x0D\x5C\xC9\x62\xC4", 1024);
   base32_encode(data2, 30, data1, 10);
-  tt_str_op(data2,==, "772w2rfobvomsywe");
+  tt_str_op(data2,OP_EQ, "772w2rfobvomsywe");
 
   /* Base16 tests */
   strlcpy(data1, "6chrs\xff", 1024);
   base16_encode(data2, 13, data1, 6);
-  tt_str_op(data2,==, "3663687273FF");
+  tt_str_op(data2,OP_EQ, "3663687273FF");
 
   strlcpy(data1, "f0d678affc000100", 1024);
   i = base16_decode(data2, 8, data1, 16);
-  tt_int_op(i,==, 0);
-  tt_mem_op(data2,==, "\xf0\xd6\x78\xaf\xfc\x00\x01\x00",8);
+  tt_int_op(i,OP_EQ, 0);
+  tt_mem_op(data2,OP_EQ, "\xf0\xd6\x78\xaf\xfc\x00\x01\x00",8);
 
   /* now try some failing base16 decodes */
-  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 */
+  tt_int_op(-1,OP_EQ, base16_decode(data2, 8, data1, 15)); /* odd input len */
+  tt_int_op(-1,OP_EQ, base16_decode(data2, 7, data1, 16)); /* dest too short */
   strlcpy(data1, "f0dz!8affc000100", 1024);
-  tt_int_op(-1,==, base16_decode(data2, 8, data1, 16));
+  tt_int_op(-1,OP_EQ, base16_decode(data2, 8, data1, 16));
 
   tor_free(data1);
   tor_free(data2);
@@ -697,10 +697,10 @@ test_crypto_formats(void *arg)
   /* Add spaces to fingerprint */
   {
     data1 = tor_strdup("ABCD1234ABCD56780000ABCD1234ABCD56780000");
-    tt_int_op(strlen(data1),==, 40);
+    tt_int_op(strlen(data1),OP_EQ, 40);
     data2 = tor_malloc(FINGERPRINT_LEN+1);
     crypto_add_spaces_to_fp(data2, FINGERPRINT_LEN+1, data1);
-    tt_str_op(data2,==, "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 0000");
+    tt_str_op(data2,OP_EQ, "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 0000");
     tor_free(data1);
     tor_free(data2);
   }
@@ -728,7 +728,7 @@ test_crypto_s2k_rfc2440(void *arg)
 
   secret_to_key_rfc2440(buf+9, 20, "", 0, buf);
   crypto_digest(buf2+9, buf3, 1024);
-  tt_mem_op(buf,==, buf2, 29);
+  tt_mem_op(buf,OP_EQ, buf2, 29);
 
   memcpy(buf,"vrbacrda",8);
   memcpy(buf2,"vrbacrda",8);
@@ -739,7 +739,7 @@ test_crypto_s2k_rfc2440(void *arg)
     memcpy(buf3+i, "vrbacrda12345678", 16);
   }
   crypto_digest(buf2+9, buf3, 65536);
-  tt_mem_op(buf,==, buf2, 29);
+  tt_mem_op(buf,OP_EQ, buf2, 29);
 
  done:
   tor_free(buf3);
@@ -757,10 +757,10 @@ run_s2k_tests(const unsigned flags, const unsigned type,
 
   r = secret_to_key_new(buf, sizeof(buf), &sz,
                         pw1, strlen(pw1), flags);
-  tt_int_op(r, ==, S2K_OKAY);
-  tt_int_op(buf[0], ==, type);
+  tt_int_op(r, OP_EQ, S2K_OKAY);
+  tt_int_op(buf[0], OP_EQ, type);
 
-  tt_int_op(sz, ==, keylen + speclen);
+  tt_int_op(sz, OP_EQ, keylen + speclen);
 
   if (legacy) {
     memmove(buf, buf+1, sz-1);
@@ -768,10 +768,10 @@ run_s2k_tests(const unsigned flags, const unsigned type,
     --speclen;
   }
 
-  tt_int_op(S2K_OKAY, ==,
+  tt_int_op(S2K_OKAY, OP_EQ,
             secret_to_key_check(buf, sz, pw1, strlen(pw1)));
 
-  tt_int_op(S2K_BAD_SECRET, ==,
+  tt_int_op(S2K_BAD_SECRET, OP_EQ,
             secret_to_key_check(buf, sz, pw2, strlen(pw2)));
 
   /* Move key to buf2, and clear it. */
@@ -780,24 +780,24 @@ run_s2k_tests(const unsigned flags, const unsigned type,
   memset(buf+speclen, 0, sz - speclen);
 
   /* Derivekey should produce the same results. */
-  tt_int_op(S2K_OKAY, ==,
+  tt_int_op(S2K_OKAY, OP_EQ,
       secret_to_key_derivekey(buf3, keylen, buf, speclen, pw1, strlen(pw1)));
 
-  tt_mem_op(buf2, ==, buf3, keylen);
+  tt_mem_op(buf2, OP_EQ, buf3, keylen);
 
   /* Derivekey with a longer output should fill the output. */
   memset(buf2, 0, sizeof(buf2));
-  tt_int_op(S2K_OKAY, ==,
+  tt_int_op(S2K_OKAY, OP_EQ,
    secret_to_key_derivekey(buf2, sizeof(buf2), buf, speclen,
                            pw1, strlen(pw1)));
 
-  tt_mem_op(buf2, !=, buf3, sizeof(buf2));
+  tt_mem_op(buf2, OP_NE, buf3, sizeof(buf2));
 
   memset(buf3, 0, sizeof(buf3));
-  tt_int_op(S2K_OKAY, ==,
+  tt_int_op(S2K_OKAY, OP_EQ,
             secret_to_key_derivekey(buf3, sizeof(buf3), buf, speclen,
                                     pw1, strlen(pw1)));
-  tt_mem_op(buf2, ==, buf3, sizeof(buf3));
+  tt_mem_op(buf2, OP_EQ, buf3, sizeof(buf3));
   tt_assert(!tor_mem_is_zero((char*)buf2+keylen, sizeof(buf2)-keylen));
 
  done:
@@ -833,50 +833,50 @@ test_crypto_s2k_errors(void *arg)
   (void)arg;
 
   /* Bogus specifiers: simple */
-  tt_int_op(S2K_BAD_LEN, ==,
+  tt_int_op(S2K_BAD_LEN, OP_EQ,
             secret_to_key_derivekey(buf, sizeof(buf),
                                     (const uint8_t*)"", 0, "ABC", 3));
-  tt_int_op(S2K_BAD_ALGORITHM, ==,
+  tt_int_op(S2K_BAD_ALGORITHM, OP_EQ,
             secret_to_key_derivekey(buf, sizeof(buf),
                                     (const uint8_t*)"\x10", 1, "ABC", 3));
-  tt_int_op(S2K_BAD_LEN, ==,
+  tt_int_op(S2K_BAD_LEN, OP_EQ,
             secret_to_key_derivekey(buf, sizeof(buf),
                                     (const uint8_t*)"\x01\x02", 2, "ABC", 3));
 
-  tt_int_op(S2K_BAD_LEN, ==,
+  tt_int_op(S2K_BAD_LEN, OP_EQ,
             secret_to_key_check((const uint8_t*)"", 0, "ABC", 3));
-  tt_int_op(S2K_BAD_ALGORITHM, ==,
+  tt_int_op(S2K_BAD_ALGORITHM, OP_EQ,
             secret_to_key_check((const uint8_t*)"\x10", 1, "ABC", 3));
-  tt_int_op(S2K_BAD_LEN, ==,
+  tt_int_op(S2K_BAD_LEN, OP_EQ,
             secret_to_key_check((const uint8_t*)"\x01\x02", 2, "ABC", 3));
 
   /* too long gets "BAD_LEN" too */
   memset(buf, 0, sizeof(buf));
   buf[0] = 2;
-  tt_int_op(S2K_BAD_LEN, ==,
+  tt_int_op(S2K_BAD_LEN, OP_EQ,
             secret_to_key_derivekey(buf2, sizeof(buf2),
                                     buf, sizeof(buf), "ABC", 3));
 
   /* Truncated output */
 #ifdef HAVE_LIBSCRYPT_H
-  tt_int_op(S2K_TRUNCATED, ==, secret_to_key_new(buf, 50, &sz,
+  tt_int_op(S2K_TRUNCATED, OP_EQ, secret_to_key_new(buf, 50, &sz,
                                                  "ABC", 3, 0));
-  tt_int_op(S2K_TRUNCATED, ==, secret_to_key_new(buf, 50, &sz,
+  tt_int_op(S2K_TRUNCATED, OP_EQ, secret_to_key_new(buf, 50, &sz,
                                                  "ABC", 3, S2K_FLAG_LOW_MEM));
 #endif
-  tt_int_op(S2K_TRUNCATED, ==, secret_to_key_new(buf, 37, &sz,
+  tt_int_op(S2K_TRUNCATED, OP_EQ, secret_to_key_new(buf, 37, &sz,
                                               "ABC", 3, S2K_FLAG_USE_PBKDF2));
-  tt_int_op(S2K_TRUNCATED, ==, secret_to_key_new(buf, 29, &sz,
+  tt_int_op(S2K_TRUNCATED, OP_EQ, secret_to_key_new(buf, 29, &sz,
                                               "ABC", 3, S2K_FLAG_NO_SCRYPT));
 
 #ifdef HAVE_LIBSCRYPT_H
-  tt_int_op(S2K_TRUNCATED, ==, secret_to_key_make_specifier(buf, 18, 0));
-  tt_int_op(S2K_TRUNCATED, ==, secret_to_key_make_specifier(buf, 18,
+  tt_int_op(S2K_TRUNCATED, OP_EQ, secret_to_key_make_specifier(buf, 18, 0));
+  tt_int_op(S2K_TRUNCATED, OP_EQ, secret_to_key_make_specifier(buf, 18,
                                                  S2K_FLAG_LOW_MEM));
 #endif
-  tt_int_op(S2K_TRUNCATED, ==, secret_to_key_make_specifier(buf, 17,
+  tt_int_op(S2K_TRUNCATED, OP_EQ, secret_to_key_make_specifier(buf, 17,
                                                  S2K_FLAG_USE_PBKDF2));
-  tt_int_op(S2K_TRUNCATED, ==, secret_to_key_make_specifier(buf, 9,
+  tt_int_op(S2K_TRUNCATED, OP_EQ, secret_to_key_make_specifier(buf, 9,
                                                  S2K_FLAG_NO_SCRYPT));
 
   /* Now try using type-specific bogus specifiers. */
@@ -886,7 +886,7 @@ test_crypto_s2k_errors(void *arg)
   memset(buf, 0, sizeof(buf));
   buf[0] = 1; /* pbkdf2 */
   buf[17] = 100; /* 1<<100 is much bigger than INT32_MAX */
-  tt_int_op(S2K_BAD_PARAMS, ==,
+  tt_int_op(S2K_BAD_PARAMS, OP_EQ,
             secret_to_key_derivekey(buf2, sizeof(buf2),
                                     buf, 18, "ABC", 3));
 
@@ -895,7 +895,7 @@ test_crypto_s2k_errors(void *arg)
   memset(buf, 0, sizeof(buf));
   buf[0] = 2; /* scrypt */
   buf[17] = 100; /* 1<<100 is much bigger than UINT64_MAX */
-  tt_int_op(S2K_BAD_PARAMS, ==,
+  tt_int_op(S2K_BAD_PARAMS, OP_EQ,
             secret_to_key_derivekey(buf2, sizeof(buf2),
                                     buf, 19, "ABC", 3));
 #endif
@@ -926,7 +926,7 @@ test_crypto_scrypt_vectors(void *arg)
   base16_decode((char*)spec, sizeof(spec),
                 "0400", 4);
   memset(out, 0x00, sizeof(out));
-  tt_int_op(64, ==,
+  tt_int_op(64, OP_EQ,
             secret_to_key_compute_key(out, 64, spec, 2, "", 0, 2));
   test_memeq_hex(out,
                  "77d6576238657b203b19ca42c18a0497"
@@ -937,7 +937,7 @@ test_crypto_scrypt_vectors(void *arg)
   base16_decode((char*)spec, sizeof(spec),
                 "4e61436c" "0A34", 12);
   memset(out, 0x00, sizeof(out));
-  tt_int_op(64, ==,
+  tt_int_op(64, OP_EQ,
             secret_to_key_compute_key(out, 64, spec, 6, "password", 8, 2));
   test_memeq_hex(out,
                  "fdbabe1c9d3472007856e7190d01e9fe"
@@ -948,7 +948,7 @@ test_crypto_scrypt_vectors(void *arg)
   base16_decode((char*)spec, sizeof(spec),
                 "536f6469756d43686c6f72696465" "0e30", 32);
   memset(out, 0x00, sizeof(out));
-  tt_int_op(64, ==,
+  tt_int_op(64, OP_EQ,
             secret_to_key_compute_key(out, 64, spec, 16,
                                       "pleaseletmein", 13, 2));
   test_memeq_hex(out,
@@ -960,7 +960,7 @@ test_crypto_scrypt_vectors(void *arg)
   base16_decode((char*)spec, sizeof(spec),
                 "536f6469756d43686c6f72696465" "1430", 32);
   memset(out, 0x00, sizeof(out));
-  tt_int_op(64, ==,
+  tt_int_op(64, OP_EQ,
             secret_to_key_compute_key(out, 64, spec, 16,
                                       "pleaseletmein", 13, 2));
   test_memeq_hex(out,
@@ -984,28 +984,28 @@ test_crypto_pbkdf2_vectors(void *arg)
   base16_decode((char*)spec, sizeof(spec),
                 "73616c74" "00" , 10);
   memset(out, 0x00, sizeof(out));
-  tt_int_op(20, ==,
+  tt_int_op(20, OP_EQ,
             secret_to_key_compute_key(out, 20, spec, 5, "password", 8, 1));
   test_memeq_hex(out, "0c60c80f961f0e71f3a9b524af6012062fe037a6");
 
   base16_decode((char*)spec, sizeof(spec),
                 "73616c74" "01" , 10);
   memset(out, 0x00, sizeof(out));
-  tt_int_op(20, ==,
+  tt_int_op(20, OP_EQ,
             secret_to_key_compute_key(out, 20, spec, 5, "password", 8, 1));
   test_memeq_hex(out, "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957");
 
   base16_decode((char*)spec, sizeof(spec),
                 "73616c74" "0C" , 10);
   memset(out, 0x00, sizeof(out));
-  tt_int_op(20, ==,
+  tt_int_op(20, OP_EQ,
             secret_to_key_compute_key(out, 20, spec, 5, "password", 8, 1));
   test_memeq_hex(out, "4b007901b765489abead49d926f721d065a429c1");
 
   base16_decode((char*)spec, sizeof(spec),
                 "73616c74" "18" , 10);
   memset(out, 0x00, sizeof(out));
-  tt_int_op(20, ==,
+  tt_int_op(20, OP_EQ,
             secret_to_key_compute_key(out, 20, spec, 5, "password", 8, 1));
   test_memeq_hex(out, "eefe3d61cd4da4e4e9945b3d6ba2158c2634e984");
 
@@ -1013,7 +1013,7 @@ test_crypto_pbkdf2_vectors(void *arg)
                 "73616c7453414c5473616c7453414c5473616c745"
                 "3414c5473616c7453414c5473616c74" "0C" , 74);
   memset(out, 0x00, sizeof(out));
-  tt_int_op(25, ==,
+  tt_int_op(25, OP_EQ,
             secret_to_key_compute_key(out, 25, spec, 37,
                                       "passwordPASSWORDpassword", 24, 1));
   test_memeq_hex(out, "3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038");
@@ -1021,7 +1021,7 @@ test_crypto_pbkdf2_vectors(void *arg)
   base16_decode((char*)spec, sizeof(spec),
                 "7361006c74" "0c" , 12);
   memset(out, 0x00, sizeof(out));
-  tt_int_op(16, ==,
+  tt_int_op(16, OP_EQ,
             secret_to_key_compute_key(out, 16, spec, 6, "pass\0word", 9, 1));
   test_memeq_hex(out, "56fa6aa75548099dcc37d7f03425e0c3");
 
@@ -1049,30 +1049,30 @@ test_crypto_pwbox(void *arg)
   (void)arg;
 
   for (i = 0; i < ARRAY_LENGTH(flags); ++i) {
-    tt_int_op(0, ==, crypto_pwbox(&boxed, &len,
+    tt_int_op(0, OP_EQ, crypto_pwbox(&boxed, &len,
                                   (const uint8_t*)msg, strlen(msg),
                                   pw, strlen(pw), flags[i]));
     tt_assert(boxed);
     tt_assert(len > 128+32);
 
-    tt_int_op(0, ==, crypto_unpwbox(&decoded, &dlen, boxed, len,
+    tt_int_op(0, OP_EQ, crypto_unpwbox(&decoded, &dlen, boxed, len,
                                     pw, strlen(pw)));
 
     tt_assert(decoded);
-    tt_uint_op(dlen, ==, strlen(msg));
-    tt_mem_op(decoded, ==, msg, dlen);
+    tt_uint_op(dlen, OP_EQ, strlen(msg));
+    tt_mem_op(decoded, OP_EQ, msg, dlen);
 
     tor_free(decoded);
 
-    tt_int_op(UNPWBOX_BAD_SECRET, ==, crypto_unpwbox(&decoded, &dlen,
+    tt_int_op(UNPWBOX_BAD_SECRET, OP_EQ, crypto_unpwbox(&decoded, &dlen,
                                                      boxed, len,
                                                      pw, strlen(pw)-1));
     boxed[len-1] ^= 1;
-    tt_int_op(UNPWBOX_BAD_SECRET, ==, crypto_unpwbox(&decoded, &dlen,
+    tt_int_op(UNPWBOX_BAD_SECRET, OP_EQ, crypto_unpwbox(&decoded, &dlen,
                                                      boxed, len,
                                                      pw, strlen(pw)));
     boxed[0] = 255;
-    tt_int_op(UNPWBOX_CORRUPTED, ==, crypto_unpwbox(&decoded, &dlen,
+    tt_int_op(UNPWBOX_CORRUPTED, OP_EQ, crypto_unpwbox(&decoded, &dlen,
                                                     boxed, len,
                                                     pw, strlen(pw)));
 
@@ -1114,79 +1114,79 @@ test_crypto_aes_iv(void *arg)
   encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted1, 16 + 4095,
                                                  plain, 4095);
 
-  tt_int_op(encrypted_size,==, 16 + 4095);
+  tt_int_op(encrypted_size,OP_EQ, 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);
 
-  tt_int_op(decrypted_size,==, 4095);
+  tt_int_op(decrypted_size,OP_EQ, 4095);
   tt_assert(decrypted_size > 0);
-  tt_mem_op(plain,==, decrypted1, 4095);
+  tt_mem_op(plain,OP_EQ, 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);
 
-  tt_int_op(encrypted_size,==, 16 + 4095);
+  tt_int_op(encrypted_size,OP_EQ, 16 + 4095);
   tt_assert(encrypted_size > 0);
   decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted2, 4095,
                                              encrypted2, encrypted_size);
-  tt_int_op(decrypted_size,==, 4095);
+  tt_int_op(decrypted_size,OP_EQ, 4095);
   tt_assert(decrypted_size > 0);
-  tt_mem_op(plain,==, decrypted2, 4095);
-  tt_mem_op(encrypted1,!=, encrypted2, encrypted_size);
+  tt_mem_op(plain,OP_EQ, decrypted2, 4095);
+  tt_mem_op(encrypted1,OP_NE, encrypted2, encrypted_size);
   /* Decrypt with the wrong key. */
   decrypted_size = crypto_cipher_decrypt_with_iv(key2, decrypted2, 4095,
                                              encrypted1, encrypted_size);
-  tt_int_op(decrypted_size,==, 4095);
-  tt_mem_op(plain,!=, decrypted2, decrypted_size);
+  tt_int_op(decrypted_size,OP_EQ, 4095);
+  tt_mem_op(plain,OP_NE, decrypted2, decrypted_size);
   /* Alter the initialization vector. */
   encrypted1[0] += 42;
   decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 4095,
                                              encrypted1, encrypted_size);
-  tt_int_op(decrypted_size,==, 4095);
-  tt_mem_op(plain,!=, decrypted2, 4095);
+  tt_int_op(decrypted_size,OP_EQ, 4095);
+  tt_mem_op(plain,OP_NE, decrypted2, 4095);
   /* Special length case: 1. */
   encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted1, 16 + 1,
                                              plain_1, 1);
-  tt_int_op(encrypted_size,==, 16 + 1);
+  tt_int_op(encrypted_size,OP_EQ, 16 + 1);
   tt_assert(encrypted_size > 0);
   decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 1,
                                              encrypted1, encrypted_size);
-  tt_int_op(decrypted_size,==, 1);
+  tt_int_op(decrypted_size,OP_EQ, 1);
   tt_assert(decrypted_size > 0);
-  tt_mem_op(plain_1,==, decrypted1, 1);
+  tt_mem_op(plain_1,OP_EQ, decrypted1, 1);
   /* Special length case: 15. */
   encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted1, 16 + 15,
                                              plain_15, 15);
-  tt_int_op(encrypted_size,==, 16 + 15);
+  tt_int_op(encrypted_size,OP_EQ, 16 + 15);
   tt_assert(encrypted_size > 0);
   decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 15,
                                              encrypted1, encrypted_size);
-  tt_int_op(decrypted_size,==, 15);
+  tt_int_op(decrypted_size,OP_EQ, 15);
   tt_assert(decrypted_size > 0);
-  tt_mem_op(plain_15,==, decrypted1, 15);
+  tt_mem_op(plain_15,OP_EQ, decrypted1, 15);
   /* Special length case: 16. */
   encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted1, 16 + 16,
                                              plain_16, 16);
-  tt_int_op(encrypted_size,==, 16 + 16);
+  tt_int_op(encrypted_size,OP_EQ, 16 + 16);
   tt_assert(encrypted_size > 0);
   decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 16,
                                              encrypted1, encrypted_size);
-  tt_int_op(decrypted_size,==, 16);
+  tt_int_op(decrypted_size,OP_EQ, 16);
   tt_assert(decrypted_size > 0);
-  tt_mem_op(plain_16,==, decrypted1, 16);
+  tt_mem_op(plain_16,OP_EQ, decrypted1, 16);
   /* Special length case: 17. */
   encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted1, 16 + 17,
                                              plain_17, 17);
-  tt_int_op(encrypted_size,==, 16 + 17);
+  tt_int_op(encrypted_size,OP_EQ, 16 + 17);
   tt_assert(encrypted_size > 0);
   decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 17,
                                              encrypted1, encrypted_size);
-  tt_int_op(decrypted_size,==, 17);
+  tt_int_op(decrypted_size,OP_EQ, 17);
   tt_assert(decrypted_size > 0);
-  tt_mem_op(plain_17,==, decrypted1, 17);
+  tt_mem_op(plain_17,OP_EQ, decrypted1, 17);
 
  done:
   /* Free memory. */
@@ -1208,26 +1208,26 @@ test_crypto_base32_decode(void *arg)
   /* Encode and decode a random string. */
   base32_encode(encoded, 96 + 1, plain, 60);
   res = base32_decode(decoded, 60, encoded, 96);
-  tt_int_op(res,==, 0);
-  tt_mem_op(plain,==, decoded, 60);
+  tt_int_op(res,OP_EQ, 0);
+  tt_mem_op(plain,OP_EQ, 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);
-  tt_int_op(res,==, 0);
-  tt_mem_op(plain,==, decoded, 60);
+  tt_int_op(res,OP_EQ, 0);
+  tt_mem_op(plain,OP_EQ, 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);
-  tt_int_op(res,==, 0);
-  tt_mem_op(plain,!=, decoded, 60);
+  tt_int_op(res,OP_EQ, 0);
+  tt_mem_op(plain,OP_NE, decoded, 60);
   /* Bad encodings. */
   encoded[0] = '!';
   res = base32_decode(decoded, 60, encoded, 96);
-  tt_int_op(0, >, res);
+  tt_int_op(0, OP_GT, res);
 
  done:
   ;
@@ -1250,7 +1250,7 @@ test_crypto_kdf_TAP(void *arg)
    * your own. */
   memset(key_material, 0, sizeof(key_material));
   EXPAND("");
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   test_memeq_hex(key_material,
                  "5ba93c9db0cff93f52b521d7420e43f6eda2784fbf8b4530d8"
                  "d246dd74ac53a13471bba17941dff7c4ea21bb365bbeeaf5f2"
@@ -1258,7 +1258,7 @@ test_crypto_kdf_TAP(void *arg)
                  "f07b01e13da42c6cf1de3abfdea9b95f34687cbbe92b9a7383");
 
   EXPAND("Tor");
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   test_memeq_hex(key_material,
                  "776c6214fc647aaa5f683c737ee66ec44f03d0372e1cce6922"
                  "7950f236ddf1e329a7ce7c227903303f525a8c6662426e8034"
@@ -1266,7 +1266,7 @@ test_crypto_kdf_TAP(void *arg)
                  "3f45dfda1a80bdc8b80de01b23e3e0ffae099b3e4ccf28dc28");
 
   EXPAND("AN ALARMING ITEM TO FIND ON A MONTHLY AUTO-DEBIT NOTICE");
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   test_memeq_hex(key_material,
                  "a340b5d126086c3ab29c2af4179196dbf95e1c72431419d331"
                  "4844bf8f6afb6098db952b95581fb6c33625709d6f4400b8e7"
@@ -1302,7 +1302,7 @@ test_crypto_hkdf_sha256(void *arg)
   /* Test vectors generated with ntor_ref.py */
   memset(key_material, 0, sizeof(key_material));
   EXPAND("");
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   test_memeq_hex(key_material,
                  "d3490ed48b12a48f9547861583573fe3f19aafe3f81dc7fc75"
                  "eeed96d741b3290f941576c1f9f0b2d463d1ec7ab2c6bf71cd"
@@ -1310,7 +1310,7 @@ test_crypto_hkdf_sha256(void *arg)
                  "dcf6abe0d20c77cf363e8ffe358927817a3d3e73712cee28d8");
 
   EXPAND("Tor");
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   test_memeq_hex(key_material,
                  "5521492a85139a8d9107a2d5c0d9c91610d0f95989975ebee6"
                  "c02a4f8d622a6cfdf9b7c7edd3832e2760ded1eac309b76f8d"
@@ -1318,7 +1318,7 @@ test_crypto_hkdf_sha256(void *arg)
                  "961be9fdb9f93197ea8e5977180801926d3321fa21513e59ac");
 
   EXPAND("AN ALARMING ITEM TO FIND ON YOUR CREDIT-RATING STATEMENT");
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   test_memeq_hex(key_material,
                  "a2aa9b50da7e481d30463adb8f233ff06e9571a0ca6ab6df0f"
                  "b206fa34e5bc78d063fc291501beec53b36e5a0e434561200c"
@@ -1381,7 +1381,7 @@ test_crypto_curve25519_impl(void *arg)
       e2k[31] |= (byte & 0x80);
     }
     curve25519_impl(e1e2k,e1,e2k);
-    tt_mem_op(e1e2k,==, e2e1k, 32);
+    tt_mem_op(e1e2k,OP_EQ, e2e1k, 32);
     if (loop == loop_max-1) {
       break;
     }
@@ -1417,7 +1417,7 @@ test_crypto_curve25519_wrappers(void *arg)
   tt_assert(curve25519_public_key_is_ok(&pubkey2));
   curve25519_handshake(output1, &seckey1, &pubkey2);
   curve25519_handshake(output2, &seckey2, &pubkey1);
-  tt_mem_op(output1,==, output2, sizeof(output1));
+  tt_mem_op(output1,OP_EQ, output2, sizeof(output1));
 
  done:
   ;
@@ -1434,26 +1434,26 @@ test_crypto_curve25519_encode(void *arg)
 
   curve25519_secret_key_generate(&seckey, 0);
   curve25519_public_key_generate(&key1, &seckey);
-  tt_int_op(0, ==, curve25519_public_to_base64(buf, &key1));
-  tt_int_op(CURVE25519_BASE64_PADDED_LEN, ==, strlen(buf));
+  tt_int_op(0, OP_EQ, curve25519_public_to_base64(buf, &key1));
+  tt_int_op(CURVE25519_BASE64_PADDED_LEN, OP_EQ, strlen(buf));
 
-  tt_int_op(0, ==, curve25519_public_from_base64(&key2, buf));
-  tt_mem_op(key1.public_key,==, key2.public_key, CURVE25519_PUBKEY_LEN);
+  tt_int_op(0, OP_EQ, curve25519_public_from_base64(&key2, buf));
+  tt_mem_op(key1.public_key,OP_EQ, 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));
-  tt_mem_op(key1.public_key,==, key3.public_key, CURVE25519_PUBKEY_LEN);
+  tt_int_op(CURVE25519_BASE64_PADDED_LEN-1, OP_EQ, strlen(buf));
+  tt_int_op(0, OP_EQ, curve25519_public_from_base64(&key3, buf));
+  tt_mem_op(key1.public_key,OP_EQ, key3.public_key, CURVE25519_PUBKEY_LEN);
 
   /* Now try bogus parses. */
   strlcpy(buf, "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$=", sizeof(buf));
-  tt_int_op(-1, ==, curve25519_public_from_base64(&key3, buf));
+  tt_int_op(-1, OP_EQ, curve25519_public_from_base64(&key3, buf));
 
   strlcpy(buf, "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$", sizeof(buf));
-  tt_int_op(-1, ==, curve25519_public_from_base64(&key3, buf));
+  tt_int_op(-1, OP_EQ, curve25519_public_from_base64(&key3, buf));
 
   strlcpy(buf, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", sizeof(buf));
-  tt_int_op(-1, ==, curve25519_public_from_base64(&key3, buf));
+  tt_int_op(-1, OP_EQ, curve25519_public_from_base64(&key3, buf));
 
  done:
   ;
@@ -1472,45 +1472,45 @@ test_crypto_curve25519_persist(void *arg)
 
   (void)arg;
 
-  tt_int_op(0,==,curve25519_keypair_generate(&keypair, 0));
+  tt_int_op(0,OP_EQ,curve25519_keypair_generate(&keypair, 0));
 
-  tt_int_op(0,==,curve25519_keypair_write_to_file(&keypair, fname, "testing"));
-  tt_int_op(0,==,curve25519_keypair_read_from_file(&keypair2, &tag, fname));
-  tt_str_op(tag,==,"testing");
+  tt_int_op(0,OP_EQ,curve25519_keypair_write_to_file(&keypair, fname, "testing"));
+  tt_int_op(0,OP_EQ,curve25519_keypair_read_from_file(&keypair2, &tag, fname));
+  tt_str_op(tag,OP_EQ,"testing");
   tor_free(tag);
 
-  tt_mem_op(keypair.pubkey.public_key,==,
+  tt_mem_op(keypair.pubkey.public_key,OP_EQ,
              keypair2.pubkey.public_key,
              CURVE25519_PUBKEY_LEN);
-  tt_mem_op(keypair.seckey.secret_key,==,
+  tt_mem_op(keypair.seckey.secret_key,OP_EQ,
              keypair2.seckey.secret_key,
              CURVE25519_SECKEY_LEN);
 
   content = read_file_to_str(fname, RFTS_BIN, &st);
   tt_assert(content);
   taglen = strlen("== c25519v1: testing ==");
-  tt_u64_op((uint64_t)st.st_size, ==,
+  tt_u64_op((uint64_t)st.st_size, OP_EQ,
             32+CURVE25519_PUBKEY_LEN+CURVE25519_SECKEY_LEN);
   tt_assert(fast_memeq(content, "== c25519v1: testing ==", taglen));
   tt_assert(tor_mem_is_zero(content+taglen, 32-taglen));
   cp = content + 32;
-  tt_mem_op(keypair.seckey.secret_key,==,
+  tt_mem_op(keypair.seckey.secret_key,OP_EQ,
              cp,
              CURVE25519_SECKEY_LEN);
   cp += CURVE25519_SECKEY_LEN;
-  tt_mem_op(keypair.pubkey.public_key,==,
+  tt_mem_op(keypair.pubkey.public_key,OP_EQ,
              cp,
              CURVE25519_SECKEY_LEN);
 
   tor_free(fname);
   fname = tor_strdup(get_fname("bogus_keypair"));
 
-  tt_int_op(-1, ==, curve25519_keypair_read_from_file(&keypair2, &tag, fname));
+  tt_int_op(-1, OP_EQ, curve25519_keypair_read_from_file(&keypair2, &tag, fname));
   tor_free(tag);
 
   content[69] ^= 0xff;
-  tt_int_op(0, ==, write_bytes_to_file(fname, content, (size_t)st.st_size, 1));
-  tt_int_op(-1, ==, curve25519_keypair_read_from_file(&keypair2, &tag, fname));
+  tt_int_op(0, OP_EQ, write_bytes_to_file(fname, content, (size_t)st.st_size, 1));
+  tt_int_op(-1, OP_EQ, curve25519_keypair_read_from_file(&keypair2, &tag, fname));
 
  done:
   tor_free(fname);
@@ -1536,41 +1536,41 @@ test_crypto_ed25519_simple(void *arg)
 
   (void)arg;
 
-  tt_int_op(0, ==, ed25519_secret_key_generate(&sec1, 0));
-  tt_int_op(0, ==, ed25519_secret_key_generate(&sec2, 1));
+  tt_int_op(0, OP_EQ, ed25519_secret_key_generate(&sec1, 0));
+  tt_int_op(0, OP_EQ, ed25519_secret_key_generate(&sec2, 1));
 
-  tt_int_op(0, ==, ed25519_public_key_generate(&pub1, &sec1));
-  tt_int_op(0, ==, ed25519_public_key_generate(&pub2, &sec1));
+  tt_int_op(0, OP_EQ, ed25519_public_key_generate(&pub1, &sec1));
+  tt_int_op(0, OP_EQ, ed25519_public_key_generate(&pub2, &sec1));
 
-  tt_mem_op(pub1.pubkey, ==, pub2.pubkey, sizeof(pub1.pubkey));
+  tt_mem_op(pub1.pubkey, OP_EQ, pub2.pubkey, sizeof(pub1.pubkey));
 
   memcpy(&kp1.pubkey, &pub1, sizeof(pub1));
   memcpy(&kp1.seckey, &sec1, sizeof(sec1));
-  tt_int_op(0, ==, ed25519_sign(&sig1, msg, msg_len, &kp1));
-  tt_int_op(0, ==, ed25519_sign(&sig2, msg, msg_len, &kp1));
+  tt_int_op(0, OP_EQ, ed25519_sign(&sig1, msg, msg_len, &kp1));
+  tt_int_op(0, OP_EQ, ed25519_sign(&sig2, msg, msg_len, &kp1));
 
   /* Ed25519 signatures are deterministic */
-  tt_mem_op(sig1.sig, ==, sig2.sig, sizeof(sig1.sig));
+  tt_mem_op(sig1.sig, OP_EQ, sig2.sig, sizeof(sig1.sig));
 
   /* Basic signature is valid. */
-  tt_int_op(0, ==, ed25519_checksig(&sig1, msg, msg_len, &pub1));
+  tt_int_op(0, OP_EQ, ed25519_checksig(&sig1, msg, msg_len, &pub1));
 
   /* Altered signature doesn't work. */
   sig1.sig[0] ^= 3;
-  tt_int_op(-1, ==, ed25519_checksig(&sig1, msg, msg_len, &pub1));
+  tt_int_op(-1, OP_EQ, ed25519_checksig(&sig1, msg, msg_len, &pub1));
 
   /* Wrong public key doesn't work. */
-  tt_int_op(0, ==, ed25519_public_key_generate(&pub2, &sec2));
-  tt_int_op(-1, ==, ed25519_checksig(&sig2, msg, msg_len, &pub2));
+  tt_int_op(0, OP_EQ, ed25519_public_key_generate(&pub2, &sec2));
+  tt_int_op(-1, OP_EQ, ed25519_checksig(&sig2, msg, msg_len, &pub2));
 
   /* Wrong message doesn't work. */
-  tt_int_op(0, ==, ed25519_checksig(&sig2, msg, msg_len, &pub1));
-  tt_int_op(-1, ==, ed25519_checksig(&sig2, msg, msg_len-1, &pub1));
-  tt_int_op(-1, ==, ed25519_checksig(&sig2, msg2, msg2_len, &pub1));
+  tt_int_op(0, OP_EQ, ed25519_checksig(&sig2, msg, msg_len, &pub1));
+  tt_int_op(-1, OP_EQ, ed25519_checksig(&sig2, msg, msg_len-1, &pub1));
+  tt_int_op(-1, OP_EQ, ed25519_checksig(&sig2, msg2, msg2_len, &pub1));
 
   /* Batch signature checking works with some bad. */
-  tt_int_op(0, ==, ed25519_keypair_generate(&kp2, 0));
-  tt_int_op(0, ==, ed25519_sign(&sig1, msg, msg_len, &kp2));
+  tt_int_op(0, OP_EQ, ed25519_keypair_generate(&kp2, 0));
+  tt_int_op(0, OP_EQ, ed25519_sign(&sig1, msg, msg_len, &kp2));
   {
     ed25519_checkable_t ch[] = {
       { &pub1, sig2, msg, msg_len }, /*ok*/
@@ -1579,12 +1579,12 @@ test_crypto_ed25519_simple(void *arg)
       { &kp2.pubkey, sig1, msg, msg_len }, /*ok*/
     };
     int okay[4];
-    tt_int_op(-2, ==, ed25519_checksig_batch(okay, ch, 4));
-    tt_int_op(okay[0], ==, 1);
-    tt_int_op(okay[1], ==, 0);
-    tt_int_op(okay[2], ==, 0);
-    tt_int_op(okay[3], ==, 1);
-    tt_int_op(-2, ==, ed25519_checksig_batch(NULL, ch, 4));
+    tt_int_op(-2, OP_EQ, ed25519_checksig_batch(okay, ch, 4));
+    tt_int_op(okay[0], OP_EQ, 1);
+    tt_int_op(okay[1], OP_EQ, 0);
+    tt_int_op(okay[2], OP_EQ, 0);
+    tt_int_op(okay[3], OP_EQ, 1);
+    tt_int_op(-2, OP_EQ, ed25519_checksig_batch(NULL, ch, 4));
   }
 
   /* Batch signature checking works with all good. */
@@ -1594,10 +1594,10 @@ test_crypto_ed25519_simple(void *arg)
       { &kp2.pubkey, sig1, msg, msg_len }, /*ok*/
     };
     int okay[2];
-    tt_int_op(0, ==, ed25519_checksig_batch(okay, ch, 2));
-    tt_int_op(okay[0], ==, 1);
-    tt_int_op(okay[1], ==, 1);
-    tt_int_op(0, ==, ed25519_checksig_batch(NULL, ch, 2));
+    tt_int_op(0, OP_EQ, ed25519_checksig_batch(okay, ch, 2));
+    tt_int_op(okay[0], OP_EQ, 1);
+    tt_int_op(okay[1], OP_EQ, 1);
+    tt_int_op(0, OP_EQ, ed25519_checksig_batch(NULL, ch, 2));
   }
 
  done:
@@ -1680,14 +1680,14 @@ test_crypto_ed25519_test_vectors(void *arg)
     base16_decode((char*)sk_seed, sizeof(sk_seed),
                   items[i].sk, 64);
     ed25519_secret_key_from_seed(&kp.seckey, sk_seed);
-    tt_int_op(0, ==, ed25519_public_key_generate(&kp.pubkey, &kp.seckey));
+    tt_int_op(0, OP_EQ, ed25519_public_key_generate(&kp.pubkey, &kp.seckey));
     test_memeq_hex(kp.pubkey.pubkey, items[i].pk);
 
     msg_len = strlen(items[i].msg) / 2;
     msg = tor_malloc(msg_len);
     base16_decode((char*)msg, msg_len, items[i].msg, strlen(items[i].msg));
 
-    tt_int_op(0, ==, ed25519_sign(&sig, msg, msg_len, &kp));
+    tt_int_op(0, OP_EQ, ed25519_sign(&sig, msg, msg_len, &kp));
     test_memeq_hex(sig.sig, items[i].sig);
 
     tor_free(msg);
@@ -1707,14 +1707,14 @@ test_crypto_ed25519_encode(void *arg)
   (void) arg;
 
   /* Test roundtrip. */
-  tt_int_op(0, ==, ed25519_keypair_generate(&kp, 0));
-  tt_int_op(0, ==, ed25519_public_to_base64(buf, &kp.pubkey));
-  tt_int_op(ED25519_BASE64_LEN, ==, strlen(buf));
-  tt_int_op(0, ==, ed25519_public_from_base64(&pk, buf));
-  tt_mem_op(kp.pubkey.pubkey, ==, pk.pubkey, ED25519_PUBKEY_LEN);
+  tt_int_op(0, OP_EQ, ed25519_keypair_generate(&kp, 0));
+  tt_int_op(0, OP_EQ, ed25519_public_to_base64(buf, &kp.pubkey));
+  tt_int_op(ED25519_BASE64_LEN, OP_EQ, strlen(buf));
+  tt_int_op(0, OP_EQ, ed25519_public_from_base64(&pk, buf));
+  tt_mem_op(kp.pubkey.pubkey, OP_EQ, pk.pubkey, ED25519_PUBKEY_LEN);
 
   /* Test known value. */
-  tt_int_op(0, ==, ed25519_public_from_base64(&pk,
+  tt_int_op(0, OP_EQ, ed25519_public_from_base64(&pk,
                              "lVIuIctLjbGZGU5wKMNXxXlSE3cW4kaqkqm04u6pxvM"));
   test_memeq_hex(pk.pubkey,
          "95522e21cb4b8db199194e7028c357c57952137716e246aa92a9b4e2eea9c6f3");
@@ -1740,21 +1740,21 @@ test_crypto_ed25519_convert(void *arg)
     int bit=0;
     ed25519_signature_t sig;
 
-    tt_int_op(0,==,curve25519_keypair_generate(&curve25519_keypair, i&1));
-    tt_int_op(0,==,ed25519_keypair_from_curve25519_keypair(
+    tt_int_op(0,OP_EQ,curve25519_keypair_generate(&curve25519_keypair, i&1));
+    tt_int_op(0,OP_EQ,ed25519_keypair_from_curve25519_keypair(
                               &ed25519_keypair, &bit, &curve25519_keypair));
-    tt_int_op(0,==,ed25519_public_key_from_curve25519_public_key(
+    tt_int_op(0,OP_EQ,ed25519_public_key_from_curve25519_public_key(
                         &ed25519_pubkey, &curve25519_keypair.pubkey, bit));
-    tt_mem_op(ed25519_pubkey.pubkey, ==, ed25519_keypair.pubkey.pubkey, 32);
+    tt_mem_op(ed25519_pubkey.pubkey, OP_EQ, ed25519_keypair.pubkey.pubkey, 32);
 
-    tt_int_op(0,==,ed25519_sign(&sig, msg, sizeof(msg), &ed25519_keypair));
-    tt_int_op(0,==,ed25519_checksig(&sig, msg, sizeof(msg),
+    tt_int_op(0,OP_EQ,ed25519_sign(&sig, msg, sizeof(msg), &ed25519_keypair));
+    tt_int_op(0,OP_EQ,ed25519_checksig(&sig, msg, sizeof(msg),
                                     &ed25519_pubkey));
 
-    tt_int_op(-1,==,ed25519_checksig(&sig, msg, sizeof(msg)-1,
+    tt_int_op(-1,OP_EQ,ed25519_checksig(&sig, msg, sizeof(msg)-1,
                                      &ed25519_pubkey));
     sig.sig[0] ^= 15;
-    tt_int_op(-1,==,ed25519_checksig(&sig, msg, sizeof(msg),
+    tt_int_op(-1,OP_EQ,ed25519_checksig(&sig, msg, sizeof(msg),
                                      &ed25519_pubkey));
   }
 
@@ -1782,26 +1782,26 @@ test_crypto_ed25519_blinding(void *arg)
 
     crypto_rand((char*) blinding, sizeof(blinding));
 
-    tt_int_op(0,==,ed25519_keypair_generate(&ed25519_keypair, 0));
-    tt_int_op(0,==,ed25519_keypair_blind(&ed25519_keypair_blinded,
+    tt_int_op(0,OP_EQ,ed25519_keypair_generate(&ed25519_keypair, 0));
+    tt_int_op(0,OP_EQ,ed25519_keypair_blind(&ed25519_keypair_blinded,
                                          &ed25519_keypair, blinding));
 
-    tt_int_op(0,==,ed25519_public_blind(&ed25519_pubkey_blinded,
+    tt_int_op(0,OP_EQ,ed25519_public_blind(&ed25519_pubkey_blinded,
                                         &ed25519_keypair.pubkey, blinding));
 
-    tt_mem_op(ed25519_pubkey_blinded.pubkey, ==,
+    tt_mem_op(ed25519_pubkey_blinded.pubkey, OP_EQ,
               ed25519_keypair_blinded.pubkey.pubkey, 32);
 
-    tt_int_op(0,==,ed25519_sign(&sig, msg, sizeof(msg),
+    tt_int_op(0,OP_EQ,ed25519_sign(&sig, msg, sizeof(msg),
                                 &ed25519_keypair_blinded));
 
-    tt_int_op(0,==,ed25519_checksig(&sig, msg, sizeof(msg),
+    tt_int_op(0,OP_EQ,ed25519_checksig(&sig, msg, sizeof(msg),
                                     &ed25519_pubkey_blinded));
 
-    tt_int_op(-1,==,ed25519_checksig(&sig, msg, sizeof(msg)-1,
+    tt_int_op(-1,OP_EQ,ed25519_checksig(&sig, msg, sizeof(msg)-1,
                                      &ed25519_pubkey_blinded));
     sig.sig[0] ^= 15;
-    tt_int_op(-1,==,ed25519_checksig(&sig, msg, sizeof(msg),
+    tt_int_op(-1,OP_EQ,ed25519_checksig(&sig, msg, sizeof(msg),
                                      &ed25519_pubkey_blinded));
   }
 
@@ -1829,43 +1829,43 @@ test_crypto_ed25519_testvectors(void *arg)
 #define DECODE(p,s) base16_decode((char*)(p),sizeof(p),(s),strlen(s))
 #define EQ(a,h) test_memeq_hex((const char*)(a), (h))
 
-    tt_int_op(0, ==, DECODE(sk, ED25519_SECRET_KEYS[i]));
-    tt_int_op(0, ==, DECODE(blinding_param, ED25519_BLINDING_PARAMS[i]));
+    tt_int_op(0, OP_EQ, DECODE(sk, ED25519_SECRET_KEYS[i]));
+    tt_int_op(0, OP_EQ, DECODE(blinding_param, ED25519_BLINDING_PARAMS[i]));
 
-    tt_int_op(0, ==, ed25519_secret_key_from_seed(&esk, sk));
+    tt_int_op(0, OP_EQ, ed25519_secret_key_from_seed(&esk, sk));
     EQ(esk.seckey, ED25519_EXPANDED_SECRET_KEYS[i]);
 
-    tt_int_op(0, ==, ed25519_public_key_generate(&pk, &esk));
+    tt_int_op(0, OP_EQ, ed25519_public_key_generate(&pk, &esk));
     EQ(pk.pubkey, ED25519_PUBLIC_KEYS[i]);
 
     memcpy(&curvekp.seckey.secret_key, esk.seckey, 32);
     curve25519_public_key_generate(&curvekp.pubkey, &curvekp.seckey);
 
-    tt_int_op(0, ==,
+    tt_int_op(0, OP_EQ,
           ed25519_keypair_from_curve25519_keypair(&keypair, &sign, &curvekp));
-    tt_int_op(0, ==, ed25519_public_key_from_curve25519_public_key(
+    tt_int_op(0, OP_EQ, ed25519_public_key_from_curve25519_public_key(
                                         &pkfromcurve, &curvekp.pubkey, sign));
-    tt_mem_op(keypair.pubkey.pubkey, ==, pkfromcurve.pubkey, 32);
+    tt_mem_op(keypair.pubkey.pubkey, OP_EQ, pkfromcurve.pubkey, 32);
     EQ(curvekp.pubkey.public_key, ED25519_CURVE25519_PUBLIC_KEYS[i]);
 
     /* Self-signing */
     memcpy(&keypair.seckey, &esk, sizeof(esk));
     memcpy(&keypair.pubkey, &pk, sizeof(pk));
 
-    tt_int_op(0, ==, ed25519_sign(&sig, pk.pubkey, 32, &keypair));
+    tt_int_op(0, OP_EQ, ed25519_sign(&sig, pk.pubkey, 32, &keypair));
 
     EQ(sig.sig, ED25519_SELF_SIGNATURES[i]);
 
     /* Blinding */
-    tt_int_op(0, ==,
+    tt_int_op(0, OP_EQ,
             ed25519_keypair_blind(&blind_keypair, &keypair, blinding_param));
-    tt_int_op(0, ==,
+    tt_int_op(0, OP_EQ,
             ed25519_public_blind(&blind_pk, &pk, blinding_param));
 
     EQ(blind_keypair.seckey.seckey, ED25519_BLINDED_SECRET_KEYS[i]);
     EQ(blind_pk.pubkey, ED25519_BLINDED_PUBLIC_KEYS[i]);
 
-    tt_mem_op(blind_pk.pubkey, ==, blind_keypair.pubkey.pubkey, 32);
+    tt_mem_op(blind_pk.pubkey, OP_EQ, blind_keypair.pubkey.pubkey, 32);
 
 #undef DECODE
 #undef EQ
@@ -1962,7 +1962,7 @@ test_crypto_siphash(void *arg)
   for (i = 0; i < 64; ++i) {
     uint64_t r = siphash24(input, i, &K);
     for (j = 0; j < 8; ++j) {
-      tt_int_op( (r >> (j*8)) & 0xff, ==, VECTORS[i][j]);
+      tt_int_op( (r >> (j*8)) & 0xff, OP_EQ, VECTORS[i][j]);
     }
   }
 
diff --git a/src/test/test_dir.c b/src/test/test_dir.c
index c7e22d8..cdf16ad 100644
--- a/src/test/test_dir.c
+++ b/src/test/test_dir.c
@@ -180,7 +180,7 @@ test_dir_formats(void *arg)
   buf[strlen(buf2)] = '\0'; /* Don't compare the sig; it's never the same
                              * twice */
 
-  tt_str_op(buf,==, buf2);
+  tt_str_op(buf,OP_EQ, buf2);
   tor_free(buf);
 
   buf = router_dump_router_to_string(r1, pk2);
@@ -188,12 +188,12 @@ test_dir_formats(void *arg)
   cp = buf;
   rp1 = router_parse_entry_from_string((const char*)cp,NULL,1,0,NULL,NULL);
   tt_assert(rp1);
-  tt_int_op(rp1->addr,==, r1->addr);
-  tt_int_op(rp1->or_port,==, r1->or_port);
+  tt_int_op(rp1->addr,OP_EQ, r1->addr);
+  tt_int_op(rp1->or_port,OP_EQ, r1->or_port);
   //test_eq(rp1->dir_port, r1->dir_port);
-  tt_int_op(rp1->bandwidthrate,==, r1->bandwidthrate);
-  tt_int_op(rp1->bandwidthburst,==, r1->bandwidthburst);
-  tt_int_op(rp1->bandwidthcapacity,==, r1->bandwidthcapacity);
+  tt_int_op(rp1->bandwidthrate,OP_EQ, r1->bandwidthrate);
+  tt_int_op(rp1->bandwidthburst,OP_EQ, r1->bandwidthburst);
+  tt_int_op(rp1->bandwidthcapacity,OP_EQ, r1->bandwidthcapacity);
   tt_assert(crypto_pk_cmp_keys(rp1->onion_pkey, pk1) == 0);
   tt_assert(crypto_pk_cmp_keys(rp1->identity_pkey, pk2) == 0);
   //tt_assert(rp1->exit_policy == NULL);
@@ -224,40 +224,40 @@ test_dir_formats(void *arg)
   buf = router_dump_router_to_string(r2, pk1);
   buf[strlen(buf2)] = '\0'; /* Don't compare the sig; it's never the same
                              * twice */
-  tt_str_op(buf,==, buf2);
+  tt_str_op(buf,OP_EQ, 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,NULL);
   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);
-  tt_mem_op(rp2->onion_curve25519_pkey->public_key,==,
+  tt_int_op(rp2->addr,OP_EQ, r2->addr);
+  tt_int_op(rp2->or_port,OP_EQ, r2->or_port);
+  tt_int_op(rp2->dir_port,OP_EQ, r2->dir_port);
+  tt_int_op(rp2->bandwidthrate,OP_EQ, r2->bandwidthrate);
+  tt_int_op(rp2->bandwidthburst,OP_EQ, r2->bandwidthburst);
+  tt_int_op(rp2->bandwidthcapacity,OP_EQ, r2->bandwidthcapacity);
+  tt_mem_op(rp2->onion_curve25519_pkey->public_key,OP_EQ,
              r2->onion_curve25519_pkey->public_key,
              CURVE25519_PUBKEY_LEN);
   tt_assert(crypto_pk_cmp_keys(rp2->onion_pkey, pk2) == 0);
   tt_assert(crypto_pk_cmp_keys(rp2->identity_pkey, pk1) == 0);
 
-  tt_int_op(smartlist_len(rp2->exit_policy),==, 2);
+  tt_int_op(smartlist_len(rp2->exit_policy),OP_EQ, 2);
 
   p = smartlist_get(rp2->exit_policy, 0);
-  tt_int_op(p->policy_type,==, ADDR_POLICY_ACCEPT);
+  tt_int_op(p->policy_type,OP_EQ, 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);
+  tt_int_op(p->maskbits,OP_EQ, 0);
+  tt_int_op(p->prt_min,OP_EQ, 80);
+  tt_int_op(p->prt_max,OP_EQ, 80);
 
   p = smartlist_get(rp2->exit_policy, 1);
-  tt_int_op(p->policy_type,==, ADDR_POLICY_REJECT);
+  tt_int_op(p->policy_type,OP_EQ, 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);
+  tt_int_op(p->maskbits,OP_EQ, 8);
+  tt_int_op(p->prt_min,OP_EQ, 24);
+  tt_int_op(p->prt_max,OP_EQ, 24);
 
 #if 0
   /* Okay, now for the directories. */
@@ -312,7 +312,7 @@ test_dir_routerparse_bad(void *arg)
     again = 999;                                                        \
     ri = router_parse_entry_from_string((s), NULL, 0, 0, NULL, &again); \
     tt_assert(ri == NULL);                                              \
-    tt_int_op(again, ==, (againval));                                   \
+    tt_int_op(again, OP_EQ, (againval));                                   \
   } while (0)
 
   CHECK_OK(EX_RI_MINIMAL);
@@ -404,7 +404,7 @@ test_dir_extrainfo_parsing(void *arg)
     again = 999;                                                        \
     ei = extrainfo_parse_entry_from_string((s), NULL, 0, map, &again);  \
     tt_assert(ei == NULL);                                              \
-    tt_int_op(again, ==, (againval));                                   \
+    tt_int_op(again, OP_EQ, (againval));                                   \
   } while (0)
 #define ADD(name)                                                       \
   do {                                                                  \
@@ -412,7 +412,7 @@ test_dir_extrainfo_parsing(void *arg)
     crypto_pk_t *pk = ri->identity_pkey = crypto_pk_new();              \
     tt_assert(! crypto_pk_read_public_key_from_string(pk,               \
                                       name##_KEY, strlen(name##_KEY))); \
-    tt_int_op(0,==,base16_decode(d, 20, name##_FP, strlen(name##_FP))); \
+    tt_int_op(0,OP_EQ,base16_decode(d, 20, name##_FP, strlen(name##_FP))); \
     digestmap_set((digestmap_t*)map, d, ri);                            \
     ri = NULL;                                                          \
   } while (0)
@@ -490,20 +490,20 @@ test_dir_parse_router_list(void *arg)
 
   /* First, parse the routers. */
   cp = list;
-  tt_int_op(0,==,
+  tt_int_op(0,OP_EQ,
             router_parse_list_from_string(&cp, NULL, dest, SAVED_NOWHERE,
                                           0, 0, NULL, invalid));
-  tt_int_op(2, ==, smartlist_len(dest));
-  tt_ptr_op(cp, ==, list + strlen(list));
+  tt_int_op(2, OP_EQ, smartlist_len(dest));
+  tt_ptr_op(cp, OP_EQ, list + strlen(list));
 
   routerinfo_t *r = smartlist_get(dest, 0);
-  tt_mem_op(r->cache_info.signed_descriptor_body, ==,
+  tt_mem_op(r->cache_info.signed_descriptor_body, OP_EQ,
             EX_RI_MINIMAL, strlen(EX_RI_MINIMAL));
   r = smartlist_get(dest, 1);
-  tt_mem_op(r->cache_info.signed_descriptor_body, ==,
+  tt_mem_op(r->cache_info.signed_descriptor_body, OP_EQ,
             EX_RI_MAXIMAL, strlen(EX_RI_MAXIMAL));
 
-  tt_int_op(2, ==, smartlist_len(invalid));
+  tt_int_op(2, OP_EQ, smartlist_len(invalid));
   test_memeq_hex(smartlist_get(invalid, 0),
                  "ab9eeaa95e7d45740185b4e519c76ead756277a9");
   test_memeq_hex(smartlist_get(invalid, 1),
@@ -523,18 +523,18 @@ test_dir_parse_router_list(void *arg)
   ADD(EX_EI_BAD_NICKNAME);
   ADD(EX_EI_BAD_PUBLISHED);
   cp = list;
-  tt_int_op(0,==,
+  tt_int_op(0,OP_EQ,
             router_parse_list_from_string(&cp, NULL, dest, SAVED_NOWHERE,
                                           1, 0, NULL, invalid));
-  tt_int_op(2, ==, smartlist_len(dest));
+  tt_int_op(2, OP_EQ, smartlist_len(dest));
   extrainfo_t *e = smartlist_get(dest, 0);
-  tt_mem_op(e->cache_info.signed_descriptor_body, ==,
+  tt_mem_op(e->cache_info.signed_descriptor_body, OP_EQ,
             EX_EI_MAXIMAL, strlen(EX_EI_MAXIMAL));
   e = smartlist_get(dest, 1);
-  tt_mem_op(e->cache_info.signed_descriptor_body, ==,
+  tt_mem_op(e->cache_info.signed_descriptor_body, OP_EQ,
             EX_EI_MINIMAL, strlen(EX_EI_MINIMAL));
 
-  tt_int_op(2, ==, smartlist_len(invalid));
+  tt_int_op(2, OP_EQ, smartlist_len(invalid));
   test_memeq_hex(smartlist_get(invalid, 0),
                  "d5df4aa62ee9ffc9543d41150c9864908e0390af");
   test_memeq_hex(smartlist_get(invalid, 1),
@@ -608,7 +608,7 @@ test_dir_load_routers(void *arg)
 
 #define ADD(str)                                                        \
   do {                                                                  \
-    tt_int_op(0,==,router_get_router_hash(str, strlen(str), buf));      \
+    tt_int_op(0,OP_EQ,router_get_router_hash(str, strlen(str), buf));      \
     smartlist_add(wanted, tor_strdup(hex_str(buf, DIGEST_LEN)));        \
   } while (0)
 
@@ -631,34 +631,34 @@ test_dir_load_routers(void *arg)
   ADD(EX_RI_BAD_TOKENS);
 
   char *list = smartlist_join_strings(chunks, "", 0, NULL);
-  tt_int_op(1, ==,
+  tt_int_op(1, OP_EQ,
             router_load_routers_from_string(list, NULL, SAVED_IN_JOURNAL,
                                             wanted, 1, NULL));
 
   /* The "maximal" router was added. */
   /* "minimal" was not. */
-  tt_int_op(smartlist_len(router_get_routerlist()->routers),==,1);
+  tt_int_op(smartlist_len(router_get_routerlist()->routers),OP_EQ,1);
   routerinfo_t *r = smartlist_get(router_get_routerlist()->routers, 0);
   test_memeq_hex(r->cache_info.signed_descriptor_digest,
                  "581D8A368A0FA854ECDBFAB841D88B3F1B004038");
-  tt_int_op(dls_minimal.n_download_failures, ==, 0);
-  tt_int_op(dls_maximal.n_download_failures, ==, 0);
+  tt_int_op(dls_minimal.n_download_failures, OP_EQ, 0);
+  tt_int_op(dls_maximal.n_download_failures, OP_EQ, 0);
 
   /* "Bad fingerprint" and "Bad tokens" should have gotten marked
    * non-retriable. */
-  tt_want_int_op(mock_router_get_dl_status_calls, ==, 2);
-  tt_want_int_op(mock_router_get_dl_status_unrecognized, ==, 0);
-  tt_int_op(dls_bad_fingerprint.n_download_failures, ==, 255);
-  tt_int_op(dls_bad_tokens.n_download_failures, ==, 255);
+  tt_want_int_op(mock_router_get_dl_status_calls, OP_EQ, 2);
+  tt_want_int_op(mock_router_get_dl_status_unrecognized, OP_EQ, 0);
+  tt_int_op(dls_bad_fingerprint.n_download_failures, OP_EQ, 255);
+  tt_int_op(dls_bad_tokens.n_download_failures, OP_EQ, 255);
 
   /* bad_sig2 and bad ports" are retriable -- one since only the signature
    * was bad, and one because we didn't ask for it. */
-  tt_int_op(dls_bad_sig2.n_download_failures, ==, 0);
-  tt_int_op(dls_bad_ports.n_download_failures, ==, 0);
+  tt_int_op(dls_bad_sig2.n_download_failures, OP_EQ, 0);
+  tt_int_op(dls_bad_ports.n_download_failures, OP_EQ, 0);
 
   /* Wanted still contains "BAD_SIG2" */
-  tt_int_op(smartlist_len(wanted), ==, 1);
-  tt_str_op(smartlist_get(wanted, 0), ==,
+  tt_int_op(smartlist_len(wanted), OP_EQ, 1);
+  tt_str_op(smartlist_get(wanted, 0), OP_EQ,
             "E0A3753CEFD54128EAB239F294954121DB23D2EF");
 
 #undef ADD
@@ -725,7 +725,7 @@ test_dir_load_extrainfo(void *arg)
 
 #define ADD(str)                                                        \
   do {                                                                  \
-    tt_int_op(0,==,router_get_extrainfo_hash(str, strlen(str), buf));   \
+    tt_int_op(0,OP_EQ,router_get_extrainfo_hash(str, strlen(str), buf));   \
     smartlist_add(wanted, tor_strdup(hex_str(buf, DIGEST_LEN)));        \
   } while (0)
 
@@ -752,7 +752,7 @@ test_dir_load_extrainfo(void *arg)
   /* The "maximal" router was added. */
   /* "minimal" was also added, even though we didn't ask for it, since
    * that's what we do with extrainfos. */
-  tt_int_op(smartlist_len(mock_ei_insert_list),==,2);
+  tt_int_op(smartlist_len(mock_ei_insert_list),OP_EQ,2);
 
   extrainfo_t *e = smartlist_get(mock_ei_insert_list, 0);
   test_memeq_hex(e->cache_info.signed_descriptor_digest,
@@ -761,22 +761,22 @@ test_dir_load_extrainfo(void *arg)
   e = smartlist_get(mock_ei_insert_list, 1);
   test_memeq_hex(e->cache_info.signed_descriptor_digest,
                  "47803B02A0E70E9E8BDA226CB1D74DE354D67DFF");
-  tt_int_op(dls_minimal.n_download_failures, ==, 0);
-  tt_int_op(dls_maximal.n_download_failures, ==, 0);
+  tt_int_op(dls_minimal.n_download_failures, OP_EQ, 0);
+  tt_int_op(dls_maximal.n_download_failures, OP_EQ, 0);
 
   /* "Bad nickname" and "Bad tokens" should have gotten marked
    * non-retriable. */
-  tt_want_int_op(mock_get_by_ei_dd_calls, ==, 2);
-  tt_want_int_op(mock_get_by_ei_dd_unrecognized, ==, 0);
-  tt_int_op(sd_ei_bad_nickname.ei_dl_status.n_download_failures, ==, 255);
-  tt_int_op(sd_ei_bad_tokens.ei_dl_status.n_download_failures, ==, 255);
+  tt_want_int_op(mock_get_by_ei_dd_calls, OP_EQ, 2);
+  tt_want_int_op(mock_get_by_ei_dd_unrecognized, OP_EQ, 0);
+  tt_int_op(sd_ei_bad_nickname.ei_dl_status.n_download_failures, OP_EQ, 255);
+  tt_int_op(sd_ei_bad_tokens.ei_dl_status.n_download_failures, OP_EQ, 255);
 
   /* bad_ports is retriable -- because we didn't ask for it. */
-  tt_int_op(dls_bad_ports.n_download_failures, ==, 0);
+  tt_int_op(dls_bad_ports.n_download_failures, OP_EQ, 0);
 
   /* Wanted still contains "BAD_SIG2" */
-  tt_int_op(smartlist_len(wanted), ==, 1);
-  tt_str_op(smartlist_get(wanted, 0), ==,
+  tt_int_op(smartlist_len(wanted), OP_EQ, 1);
+  tt_str_op(smartlist_get(wanted, 0), OP_EQ,
             "16D387D3A58F7DB3CF46638F8D0B90C45C7D769C");
 
 #undef ADD
@@ -797,50 +797,50 @@ test_dir_versions(void *arg)
 
   /* Try out version parsing functionality */
   (void)arg;
-  tt_int_op(0,==, tor_version_parse("0.3.4pre2-cvs", &ver1));
-  tt_int_op(0,==, ver1.major);
-  tt_int_op(3,==, ver1.minor);
-  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);
+  tt_int_op(0,OP_EQ, tor_version_parse("0.3.4pre2-cvs", &ver1));
+  tt_int_op(0,OP_EQ, ver1.major);
+  tt_int_op(3,OP_EQ, ver1.minor);
+  tt_int_op(4,OP_EQ, ver1.micro);
+  tt_int_op(VER_PRE,OP_EQ, ver1.status);
+  tt_int_op(2,OP_EQ, ver1.patchlevel);
+  tt_int_op(0,OP_EQ, tor_version_parse("0.3.4rc1", &ver1));
+  tt_int_op(0,OP_EQ, ver1.major);
+  tt_int_op(3,OP_EQ, ver1.minor);
+  tt_int_op(4,OP_EQ, ver1.micro);
+  tt_int_op(VER_RC,OP_EQ, ver1.status);
+  tt_int_op(1,OP_EQ, ver1.patchlevel);
+  tt_int_op(0,OP_EQ, tor_version_parse("1.3.4", &ver1));
+  tt_int_op(1,OP_EQ, ver1.major);
+  tt_int_op(3,OP_EQ, ver1.minor);
+  tt_int_op(4,OP_EQ, ver1.micro);
+  tt_int_op(VER_RELEASE,OP_EQ, ver1.status);
+  tt_int_op(0,OP_EQ, ver1.patchlevel);
+  tt_int_op(0,OP_EQ, tor_version_parse("1.3.4.999", &ver1));
+  tt_int_op(1,OP_EQ, ver1.major);
+  tt_int_op(3,OP_EQ, ver1.minor);
+  tt_int_op(4,OP_EQ, ver1.micro);
+  tt_int_op(VER_RELEASE,OP_EQ, ver1.status);
+  tt_int_op(999,OP_EQ, ver1.patchlevel);
+  tt_int_op(0,OP_EQ, tor_version_parse("0.1.2.4-alpha", &ver1));
+  tt_int_op(0,OP_EQ, ver1.major);
+  tt_int_op(1,OP_EQ, ver1.minor);
+  tt_int_op(2,OP_EQ, ver1.micro);
+  tt_int_op(4,OP_EQ, ver1.patchlevel);
+  tt_int_op(VER_RELEASE,OP_EQ, ver1.status);
+  tt_str_op("alpha",OP_EQ, ver1.status_tag);
+  tt_int_op(0,OP_EQ, tor_version_parse("0.1.2.4", &ver1));
+  tt_int_op(0,OP_EQ, ver1.major);
+  tt_int_op(1,OP_EQ, ver1.minor);
+  tt_int_op(2,OP_EQ, ver1.micro);
+  tt_int_op(4,OP_EQ, ver1.patchlevel);
+  tt_int_op(VER_RELEASE,OP_EQ, ver1.status);
+  tt_str_op("",OP_EQ, ver1.status_tag);
 
 #define tt_versionstatus_op(vs1, op, vs2)                               \
   tt_assert_test_type(vs1,vs2,#vs1" "#op" "#vs2,version_status_t,       \
                       (val1_ op val2_),"%d",TT_EXIT_TEST_FUNCTION)
 #define test_v_i_o(val, ver, lst)                                       \
-  tt_versionstatus_op(val, ==, tor_version_is_obsolete(ver, lst))
+  tt_versionstatus_op(val, OP_EQ, tor_version_is_obsolete(ver, lst))
 
   /* make sure tor_version_is_obsolete() works */
   test_v_i_o(VS_OLD, "0.0.1", "Tor 0.0.2");
@@ -867,42 +867,42 @@ test_dir_versions(void *arg)
   /* 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");
-  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(
+  tt_int_op(0,OP_EQ, tor_version_as_new_as("Tor 0.0.5", "0.0.9pre1-cvs"));
+  tt_int_op(1,OP_EQ, 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"));
-  tt_int_op(0,==, tor_version_as_new_as(
+  tt_int_op(0,OP_EQ, 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. */
-  tt_int_op(1,==, tor_version_as_new_as("Tor 0.2.1.0-dev (r100)",
+  tt_int_op(1,OP_EQ, tor_version_as_new_as("Tor 0.2.1.0-dev (r100)",
                                    "Tor 0.2.1.0-dev (r99)"));
-  tt_int_op(1,==, tor_version_as_new_as("Tor 0.2.1.0-dev (r100) on Banana Jr",
+  tt_int_op(1,OP_EQ, 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"));
-  tt_int_op(1,==, tor_version_as_new_as("Tor 0.2.1.0-dev (r100)",
+  tt_int_op(1,OP_EQ, tor_version_as_new_as("Tor 0.2.1.0-dev (r100)",
                                    "Tor 0.2.1.0-dev on Colossus"));
-  tt_int_op(0,==, tor_version_as_new_as("Tor 0.2.1.0-dev (r99)",
+  tt_int_op(0,OP_EQ, tor_version_as_new_as("Tor 0.2.1.0-dev (r99)",
                                    "Tor 0.2.1.0-dev (r100)"));
-  tt_int_op(0,==, tor_version_as_new_as("Tor 0.2.1.0-dev (r99) on MCP",
+  tt_int_op(0,OP_EQ, tor_version_as_new_as("Tor 0.2.1.0-dev (r99) on MCP",
                                    "Tor 0.2.1.0-dev (r100) on AM"));
-  tt_int_op(0,==, tor_version_as_new_as("Tor 0.2.1.0-dev",
+  tt_int_op(0,OP_EQ, tor_version_as_new_as("Tor 0.2.1.0-dev",
                                    "Tor 0.2.1.0-dev (r99)"));
-  tt_int_op(1,==, tor_version_as_new_as("Tor 0.2.1.1",
+  tt_int_op(1,OP_EQ, tor_version_as_new_as("Tor 0.2.1.1",
                                    "Tor 0.2.1.0-dev (r99)"));
 
   /* Now try git revisions */
-  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));
+  tt_int_op(0,OP_EQ, tor_version_parse("0.5.6.7 (git-ff00ff)", &ver1));
+  tt_int_op(0,OP_EQ, ver1.major);
+  tt_int_op(5,OP_EQ, ver1.minor);
+  tt_int_op(6,OP_EQ, ver1.micro);
+  tt_int_op(7,OP_EQ, ver1.patchlevel);
+  tt_int_op(3,OP_EQ, ver1.git_tag_len);
+  tt_mem_op(ver1.git_tag,OP_EQ, "\xff\x00\xff", 3);
+  tt_int_op(-1,OP_EQ, tor_version_parse("0.5.6.7 (git-ff00xx)", &ver1));
+  tt_int_op(-1,OP_EQ, tor_version_parse("0.5.6.7 (git-ff00fff)", &ver1));
+  tt_int_op(0,OP_EQ, tor_version_parse("0.5.6.7 (git ff00fff)", &ver1));
  done:
   ;
 }
@@ -924,13 +924,13 @@ test_dir_fp_pairs(void *arg)
        "48657861646563696d616c2069736e277420736f-"
        "676f6f6420666f7220686964696e6720796f7572.z", sl);
 
-  tt_int_op(smartlist_len(sl),==, 2);
+  tt_int_op(smartlist_len(sl),OP_EQ, 2);
   pair = smartlist_get(sl, 0);
-  tt_mem_op(pair->first,==,  "Hexadecimal isn't so", DIGEST_LEN);
-  tt_mem_op(pair->second,==, "good for hiding your", DIGEST_LEN);
+  tt_mem_op(pair->first,OP_EQ,  "Hexadecimal isn't so", DIGEST_LEN);
+  tt_mem_op(pair->second,OP_EQ, "good for hiding your", DIGEST_LEN);
   pair = smartlist_get(sl, 1);
-  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);
+  tt_mem_op(pair->first,OP_EQ,  "secret data.\0\0\0\0\0\xff\xff\xff", DIGEST_LEN);
+  tt_mem_op(pair->second,OP_EQ, "Use AES-256 instead.", DIGEST_LEN);
 
  done:
   SMARTLIST_FOREACH(sl, fp_pair_t *, pair, tor_free(pair));
@@ -961,56 +961,56 @@ test_dir_split_fps(void *testdata)
 
   /* no flags set */
   dir_split_resource_into_fingerprints("A+C+B", sl, NULL, 0);
-  tt_int_op(smartlist_len(sl), ==, 3);
-  tt_str_op(smartlist_get(sl, 0), ==, "A");
-  tt_str_op(smartlist_get(sl, 1), ==, "C");
-  tt_str_op(smartlist_get(sl, 2), ==, "B");
+  tt_int_op(smartlist_len(sl), OP_EQ, 3);
+  tt_str_op(smartlist_get(sl, 0), OP_EQ, "A");
+  tt_str_op(smartlist_get(sl, 1), OP_EQ, "C");
+  tt_str_op(smartlist_get(sl, 2), OP_EQ, "B");
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
 
   /* uniq strings. */
   dir_split_resource_into_fingerprints("A+C+B+A+B+B", sl, NULL, DSR_SORT_UNIQ);
-  tt_int_op(smartlist_len(sl), ==, 3);
-  tt_str_op(smartlist_get(sl, 0), ==, "A");
-  tt_str_op(smartlist_get(sl, 1), ==, "B");
-  tt_str_op(smartlist_get(sl, 2), ==, "C");
+  tt_int_op(smartlist_len(sl), OP_EQ, 3);
+  tt_str_op(smartlist_get(sl, 0), OP_EQ, "A");
+  tt_str_op(smartlist_get(sl, 1), OP_EQ, "B");
+  tt_str_op(smartlist_get(sl, 2), OP_EQ, "C");
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
 
   /* Decode hex. */
   dir_split_resource_into_fingerprints(HEX1"+"HEX2, sl, NULL, DSR_HEX);
-  tt_int_op(smartlist_len(sl), ==, 2);
-  test_mem_op_hex(smartlist_get(sl, 0), ==, HEX1);
-  test_mem_op_hex(smartlist_get(sl, 1), ==, HEX2);
+  tt_int_op(smartlist_len(sl), OP_EQ, 2);
+  test_mem_op_hex(smartlist_get(sl, 0), OP_EQ, HEX1);
+  test_mem_op_hex(smartlist_get(sl, 1), OP_EQ, HEX2);
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
 
   /* decode hex and drop weirdness. */
   dir_split_resource_into_fingerprints(HEX1"+bogus+"HEX2"+"HEX256_1,
                                        sl, NULL, DSR_HEX);
-  tt_int_op(smartlist_len(sl), ==, 2);
-  test_mem_op_hex(smartlist_get(sl, 0), ==, HEX1);
-  test_mem_op_hex(smartlist_get(sl, 1), ==, HEX2);
+  tt_int_op(smartlist_len(sl), OP_EQ, 2);
+  test_mem_op_hex(smartlist_get(sl, 0), OP_EQ, HEX1);
+  test_mem_op_hex(smartlist_get(sl, 1), OP_EQ, HEX2);
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
 
   /* Decode long hex */
   dir_split_resource_into_fingerprints(HEX256_1"+"HEX256_2"+"HEX2"+"HEX256_3,
                                        sl, NULL, DSR_HEX|DSR_DIGEST256);
-  tt_int_op(smartlist_len(sl), ==, 3);
-  test_mem_op_hex(smartlist_get(sl, 0), ==, HEX256_1);
-  test_mem_op_hex(smartlist_get(sl, 1), ==, HEX256_2);
-  test_mem_op_hex(smartlist_get(sl, 2), ==, HEX256_3);
+  tt_int_op(smartlist_len(sl), OP_EQ, 3);
+  test_mem_op_hex(smartlist_get(sl, 0), OP_EQ, HEX256_1);
+  test_mem_op_hex(smartlist_get(sl, 1), OP_EQ, HEX256_2);
+  test_mem_op_hex(smartlist_get(sl, 2), OP_EQ, HEX256_3);
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
 
   /* Decode hex and sort. */
   dir_split_resource_into_fingerprints(HEX1"+"HEX2"+"HEX3"+"HEX2,
                                        sl, NULL, DSR_HEX|DSR_SORT_UNIQ);
-  tt_int_op(smartlist_len(sl), ==, 3);
-  test_mem_op_hex(smartlist_get(sl, 0), ==, HEX3);
-  test_mem_op_hex(smartlist_get(sl, 1), ==, HEX2);
-  test_mem_op_hex(smartlist_get(sl, 2), ==, HEX1);
+  tt_int_op(smartlist_len(sl), OP_EQ, 3);
+  test_mem_op_hex(smartlist_get(sl, 0), OP_EQ, HEX3);
+  test_mem_op_hex(smartlist_get(sl, 1), OP_EQ, HEX2);
+  test_mem_op_hex(smartlist_get(sl, 2), OP_EQ, HEX1);
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
 
@@ -1019,34 +1019,34 @@ test_dir_split_fps(void *testdata)
                                        "+"HEX256_1,
                                        sl, NULL,
                                        DSR_HEX|DSR_DIGEST256|DSR_SORT_UNIQ);
-  tt_int_op(smartlist_len(sl), ==, 3);
-  test_mem_op_hex(smartlist_get(sl, 0), ==, HEX256_3);
-  test_mem_op_hex(smartlist_get(sl, 1), ==, HEX256_2);
-  test_mem_op_hex(smartlist_get(sl, 2), ==, HEX256_1);
+  tt_int_op(smartlist_len(sl), OP_EQ, 3);
+  test_mem_op_hex(smartlist_get(sl, 0), OP_EQ, HEX256_3);
+  test_mem_op_hex(smartlist_get(sl, 1), OP_EQ, HEX256_2);
+  test_mem_op_hex(smartlist_get(sl, 2), OP_EQ, HEX256_1);
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
 
   /* Decode base64 */
   dir_split_resource_into_fingerprints(B64_1"-"B64_2, sl, NULL, DSR_BASE64);
-  tt_int_op(smartlist_len(sl), ==, 2);
-  test_mem_op_hex(smartlist_get(sl, 0), ==, HEX1);
-  test_mem_op_hex(smartlist_get(sl, 1), ==, HEX2);
+  tt_int_op(smartlist_len(sl), OP_EQ, 2);
+  test_mem_op_hex(smartlist_get(sl, 0), OP_EQ, HEX1);
+  test_mem_op_hex(smartlist_get(sl, 1), OP_EQ, HEX2);
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
 
   /* Decode long base64 */
   dir_split_resource_into_fingerprints(B64_256_1"-"B64_256_2,
                                        sl, NULL, DSR_BASE64|DSR_DIGEST256);
-  tt_int_op(smartlist_len(sl), ==, 2);
-  test_mem_op_hex(smartlist_get(sl, 0), ==, HEX256_1);
-  test_mem_op_hex(smartlist_get(sl, 1), ==, HEX256_2);
+  tt_int_op(smartlist_len(sl), OP_EQ, 2);
+  test_mem_op_hex(smartlist_get(sl, 0), OP_EQ, HEX256_1);
+  test_mem_op_hex(smartlist_get(sl, 1), OP_EQ, HEX256_2);
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
 
   dir_split_resource_into_fingerprints(B64_256_1,
                                        sl, NULL, DSR_BASE64|DSR_DIGEST256);
-  tt_int_op(smartlist_len(sl), ==, 1);
-  test_mem_op_hex(smartlist_get(sl, 0), ==, HEX256_1);
+  tt_int_op(smartlist_len(sl), OP_EQ, 1);
+  test_mem_op_hex(smartlist_get(sl, 0), OP_EQ, HEX256_1);
   SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
   smartlist_clear(sl);
 
@@ -1140,7 +1140,7 @@ test_dir_measured_bw_kb_cache(void *arg)
   /* First, clear the cache and assert that it's empty */
   (void)arg;
   dirserv_clear_measured_bw_cache();
-  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 0);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 0);
   /*
    * Set up test mbwls; none of the dirserv_cache_*() functions care about
    * the node_hex field.
@@ -1153,49 +1153,49 @@ test_dir_measured_bw_kb_cache(void *arg)
   mbwl[2].bw_kb = 80;
   /* Try caching something */
   dirserv_cache_measured_bw(&(mbwl[0]), curr);
-  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 1);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 1);
   /* Okay, let's see if we can retrieve it */
   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);
+  tt_int_op(bw,OP_EQ, 20);
+  tt_int_op(as_of,OP_EQ, MBWC_INIT_TIME);
   /* Try retrieving it without some outputs */
   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_int_op(bw,OP_EQ, 20);
   tt_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,NULL,&as_of));
-  tt_int_op(as_of,==, MBWC_INIT_TIME);
+  tt_int_op(as_of,OP_EQ, MBWC_INIT_TIME);
   /* Now expire it */
   curr += MAX_MEASUREMENT_AGE + 1;
   dirserv_expire_measured_bw_cache(curr);
   /* Check that the cache is empty */
-  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 0);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 0);
   /* Check that we can't retrieve it */
   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);
-  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 1);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 1);
   curr += MAX_MEASUREMENT_AGE / 4;
   dirserv_cache_measured_bw(&(mbwl[1]), curr);
-  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 2);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 2);
   curr += MAX_MEASUREMENT_AGE / 4;
   dirserv_cache_measured_bw(&(mbwl[2]), curr);
-  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 3);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 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);
-  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 3);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 3);
   /* Push the oldest one off the cliff */
   curr += MAX_MEASUREMENT_AGE / 4;
   dirserv_expire_measured_bw_cache(curr);
-  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 2);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 2);
   /* And another... */
   curr += MAX_MEASUREMENT_AGE / 4;
   dirserv_expire_measured_bw_cache(curr);
-  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 1);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 1);
   /* This should empty it out again */
   curr += MAX_MEASUREMENT_AGE / 4;
   dirserv_expire_measured_bw_cache(curr);
-  tt_int_op(dirserv_get_measured_bw_cache_size(),==, 0);
+  tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 0);
 
  done:
   return;
@@ -1228,11 +1228,11 @@ test_dir_param_voting(void *arg)
                          "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);
-  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));
+  tt_int_op(100,OP_EQ, networkstatus_get_param(&vote4, "x-yz", 50, 0, 300));
+  tt_int_op(222,OP_EQ, networkstatus_get_param(&vote4, "foobar", 222, 0, 300));
+  tt_int_op(80,OP_EQ, networkstatus_get_param(&vote4, "ab", 12, 0, 80));
+  tt_int_op(-8,OP_EQ, networkstatus_get_param(&vote4, "ab", -12, -100, -8));
+  tt_int_op(0,OP_EQ, networkstatus_get_param(&vote4, "foobar", 0, -100, 8));
 
   smartlist_add(votes, &vote1);
 
@@ -1240,59 +1240,59 @@ test_dir_param_voting(void *arg)
    * networks without many dirauths. */
 
   res = dirvote_compute_params(votes, 12, 2);
-  tt_str_op(res,==, "");
+  tt_str_op(res,OP_EQ, "");
   tor_free(res);
 
   res = dirvote_compute_params(votes, 12, 1);
-  tt_str_op(res,==, "ab=90 abcd=20 cw=50 x-yz=-99");
+  tt_str_op(res,OP_EQ, "ab=90 abcd=20 cw=50 x-yz=-99");
   tor_free(res);
 
   smartlist_add(votes, &vote2);
 
   res = dirvote_compute_params(votes, 12, 2);
-  tt_str_op(res,==, "ab=27 cw=5 x-yz=-99");
+  tt_str_op(res,OP_EQ, "ab=27 cw=5 x-yz=-99");
   tor_free(res);
 
   res = dirvote_compute_params(votes, 12, 3);
-  tt_str_op(res,==, "ab=27 cw=5 x-yz=-99");
+  tt_str_op(res,OP_EQ, "ab=27 cw=5 x-yz=-99");
   tor_free(res);
 
   res = dirvote_compute_params(votes, 12, 6);
-  tt_str_op(res,==, "");
+  tt_str_op(res,OP_EQ, "");
   tor_free(res);
 
   smartlist_add(votes, &vote3);
 
   res = dirvote_compute_params(votes, 12, 3);
-  tt_str_op(res,==, "ab=27 abcd=20 cw=50 x-yz=-9");
+  tt_str_op(res,OP_EQ, "ab=27 abcd=20 cw=50 x-yz=-9");
   tor_free(res);
 
   res = dirvote_compute_params(votes, 12, 5);
-  tt_str_op(res,==, "cw=50 x-yz=-9");
+  tt_str_op(res,OP_EQ, "cw=50 x-yz=-9");
   tor_free(res);
 
   res = dirvote_compute_params(votes, 12, 9);
-  tt_str_op(res,==, "cw=50 x-yz=-9");
+  tt_str_op(res,OP_EQ, "cw=50 x-yz=-9");
   tor_free(res);
 
   smartlist_add(votes, &vote4);
 
   res = dirvote_compute_params(votes, 12, 4);
-  tt_str_op(res,==, "ab=90 abcd=20 cw=50 x-yz=-9");
+  tt_str_op(res,OP_EQ, "ab=90 abcd=20 cw=50 x-yz=-9");
   tor_free(res);
 
   res = dirvote_compute_params(votes, 12, 5);
-  tt_str_op(res,==, "ab=90 abcd=20 cw=50 x-yz=-9");
+  tt_str_op(res,OP_EQ, "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);
-  tt_str_op(res,==, "ab=90 abcd=20 cw=50 x-yz=-9");
+  tt_str_op(res,OP_EQ, "ab=90 abcd=20 cw=50 x-yz=-9");
   tor_free(res);
 
   res = dirvote_compute_params(votes, 12, 10);
-  tt_str_op(res,==, "ab=90 abcd=20 cw=50 x-yz=-9");
+  tt_str_op(res,OP_EQ, "ab=90 abcd=20 cw=50 x-yz=-9");
   tor_free(res);
 
  done:
@@ -1324,14 +1324,14 @@ static void
 test_same_voter(networkstatus_voter_info_t *v1,
                 networkstatus_voter_info_t *v2)
 {
-  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);
+  tt_str_op(v1->nickname,OP_EQ, v2->nickname);
+  tt_mem_op(v1->identity_digest,OP_EQ, v2->identity_digest, DIGEST_LEN);
+  tt_str_op(v1->address,OP_EQ, v2->address);
+  tt_int_op(v1->addr,OP_EQ, v2->addr);
+  tt_int_op(v1->dir_port,OP_EQ, v2->dir_port);
+  tt_int_op(v1->or_port,OP_EQ, v2->or_port);
+  tt_str_op(v1->contact,OP_EQ, v2->contact);
+  tt_mem_op(v1->vote_digest,OP_EQ, v2->vote_digest, DIGEST_LEN);
  done:
   ;
 }
@@ -1541,48 +1541,48 @@ test_vrs_for_v3ns(vote_routerstatus_t *vrs, int voter, time_t now)
                 DIGEST_LEN) &&
                 (voter == 1)) {
     /* Check the first routerstatus. */
-    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,==,
+    tt_str_op(vrs->version,OP_EQ, "0.1.2.14");
+    tt_int_op(rs->published_on,OP_EQ, now-1500);
+    tt_str_op(rs->nickname,OP_EQ, "router2");
+    tt_mem_op(rs->identity_digest,OP_EQ,
                "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3"
                "\x3\x3\x3\x3",
                DIGEST_LEN);
-    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_mem_op(rs->descriptor_digest,OP_EQ, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN);
+    tt_int_op(rs->addr,OP_EQ, 0x99008801);
+    tt_int_op(rs->or_port,OP_EQ, 443);
+    tt_int_op(rs->dir_port,OP_EQ, 8000);
     /* no flags except "running" (16) and "v2dir" (64) */
-    tt_u64_op(vrs->flags, ==, U64_LITERAL(80));
+    tt_u64_op(vrs->flags, OP_EQ, U64_LITERAL(80));
   } 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) &&
                        (voter == 1 || voter == 2)) {
-    tt_mem_op(rs->identity_digest,==,
+    tt_mem_op(rs->identity_digest,OP_EQ,
                "\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. */
-      tt_str_op(vrs->version,==, "0.2.0.5");
-      tt_int_op(rs->published_on,==, now-1000);
-      tt_str_op(rs->nickname,==, "router1");
+      tt_str_op(vrs->version,OP_EQ, "0.2.0.5");
+      tt_int_op(rs->published_on,OP_EQ, now-1000);
+      tt_str_op(rs->nickname,OP_EQ, "router1");
     }
-    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);
+    tt_mem_op(rs->descriptor_digest,OP_EQ, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN);
+    tt_int_op(rs->addr,OP_EQ, 0x99009901);
+    tt_int_op(rs->or_port,OP_EQ, 443);
+    tt_int_op(rs->dir_port,OP_EQ, 0);
     tor_addr_parse(&addr_ipv6, "[1:2:3::4]");
     tt_assert(tor_addr_eq(&rs->ipv6_addr, &addr_ipv6));
-    tt_int_op(rs->ipv6_orport,==, 4711);
+    tt_int_op(rs->ipv6_orport,OP_EQ, 4711);
     if (voter == 1) {
       /* all except "authority" (1) and "v2dir" (64) */
-      tt_u64_op(vrs->flags, ==, U64_LITERAL(190));
+      tt_u64_op(vrs->flags, OP_EQ, U64_LITERAL(190));
     } else {
       /* 1023 - authority(1) - madeofcheese(16) - madeoftin(32) - v2dir(256) */
-      tt_u64_op(vrs->flags, ==, U64_LITERAL(718));
+      tt_u64_op(vrs->flags, OP_EQ, U64_LITERAL(718));
     }
   } else if (tor_memeq(rs->identity_digest,
                        "\x33\x33\x33\x33\x33\x33\x33\x33\x33\x33"
@@ -1614,7 +1614,7 @@ test_consensus_for_v3ns(networkstatus_t *con, time_t now)
 
   tt_assert(con);
   tt_assert(!con->cert);
-  tt_int_op(2,==, smartlist_len(con->routerstatus_list));
+  tt_int_op(2,OP_EQ, smartlist_len(con->routerstatus_list));
   /* There should be two listed routers: one with identity 3, one with
    * identity 5. */
 
@@ -1639,10 +1639,10 @@ 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)) {
-    tt_mem_op(rs->identity_digest,==,
+    tt_mem_op(rs->identity_digest,OP_EQ,
                "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3",
                DIGEST_LEN);
-    tt_mem_op(rs->descriptor_digest,==, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN);
+    tt_mem_op(rs->descriptor_digest,OP_EQ, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN);
     tt_assert(!rs->is_authority);
     tt_assert(!rs->is_exit);
     tt_assert(!rs->is_fast);
@@ -1658,18 +1658,18 @@ test_routerstatus_for_v3ns(routerstatus_t *rs, time_t now)
                        "\x5\x5\x5\x5",
                        DIGEST_LEN)) {
     /* This one showed up in 3 digests. Twice with ID 'M', once with 'Z'.  */
-    tt_mem_op(rs->identity_digest,==,
+    tt_mem_op(rs->identity_digest,OP_EQ,
                "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5",
                DIGEST_LEN);
-    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);
+    tt_str_op(rs->nickname,OP_EQ, "router1");
+    tt_mem_op(rs->descriptor_digest,OP_EQ, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN);
+    tt_int_op(rs->published_on,OP_EQ, now-1000);
+    tt_int_op(rs->addr,OP_EQ, 0x99009901);
+    tt_int_op(rs->or_port,OP_EQ, 443);
+    tt_int_op(rs->dir_port,OP_EQ, 0);
     tor_addr_parse(&addr_ipv6, "[1:2:3::4]");
     tt_assert(tor_addr_eq(&rs->ipv6_addr, &addr_ipv6));
-    tt_int_op(rs->ipv6_orport,==, 4711);
+    tt_int_op(rs->ipv6_orport,OP_EQ, 4711);
     tt_assert(!rs->is_authority);
     tt_assert(rs->is_exit);
     tt_assert(rs->is_fast);
@@ -1809,29 +1809,29 @@ test_a_networkstatus(
   tt_assert(v1);
 
   /* Make sure the parsed thing was right. */
-  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_int_op(v1->type,OP_EQ, NS_TYPE_VOTE);
+  tt_int_op(v1->published,OP_EQ, vote->published);
+  tt_int_op(v1->valid_after,OP_EQ, vote->valid_after);
+  tt_int_op(v1->fresh_until,OP_EQ, vote->fresh_until);
+  tt_int_op(v1->valid_until,OP_EQ, vote->valid_until);
+  tt_int_op(v1->vote_seconds,OP_EQ, vote->vote_seconds);
+  tt_int_op(v1->dist_seconds,OP_EQ, vote->dist_seconds);
+  tt_str_op(v1->client_versions,OP_EQ, vote->client_versions);
+  tt_str_op(v1->server_versions,OP_EQ, vote->server_versions);
   tt_assert(v1->voters && smartlist_len(v1->voters));
   voter = smartlist_get(v1->voters, 0);
-  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@xxxxxxxxxxx");
+  tt_str_op(voter->nickname,OP_EQ, "Voter1");
+  tt_str_op(voter->address,OP_EQ, "1.2.3.4");
+  tt_int_op(voter->addr,OP_EQ, 0x01020304);
+  tt_int_op(voter->dir_port,OP_EQ, 80);
+  tt_int_op(voter->or_port,OP_EQ, 9000);
+  tt_str_op(voter->contact,OP_EQ, "voter@xxxxxxxxxxx");
   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);
-  tt_str_op(cp,==, "Authority:Exit:Fast:Guard:Running:Stable:V2Dir:Valid");
+  tt_str_op(cp,OP_EQ, "Authority:Exit:Fast:Guard:Running:Stable:V2Dir:Valid");
   tor_free(cp);
-  tt_int_op(smartlist_len(v1->routerstatus_list),==, n_vrs);
+  tt_int_op(smartlist_len(v1->routerstatus_list),OP_EQ, n_vrs);
 
   if (vote_tweaks) params_tweaked += vote_tweaks(v1, 1, now);
 
@@ -1876,7 +1876,7 @@ test_a_networkstatus(
 
   /* Check that flags come out right.*/
   cp = smartlist_join_strings(v2->known_flags, ":", 0, NULL);
-  tt_str_op(cp,==, "Authority:Exit:Fast:Guard:MadeOfCheese:MadeOfTin:"
+  tt_str_op(cp,OP_EQ, "Authority:Exit:Fast:Guard:MadeOfCheese:MadeOfTin:"
              "Running:Stable:V2Dir:Valid");
   tor_free(cp);
 
@@ -1945,30 +1945,30 @@ test_a_networkstatus(
   con_md = networkstatus_parse_vote_from_string(consensus_text_md, NULL,
                                                 NS_TYPE_CONSENSUS);
   tt_assert(con_md);
-  tt_int_op(con_md->flavor,==, FLAV_MICRODESC);
+  tt_int_op(con_md->flavor,OP_EQ, FLAV_MICRODESC);
 
   /* Check consensus contents. */
   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");
+  tt_int_op(con->published,OP_EQ, 0); /* this field only appears in votes. */
+  tt_int_op(con->valid_after,OP_EQ, now+1000);
+  tt_int_op(con->fresh_until,OP_EQ, now+2003); /* median */
+  tt_int_op(con->valid_until,OP_EQ, now+3000);
+  tt_int_op(con->vote_seconds,OP_EQ, 100);
+  tt_int_op(con->dist_seconds,OP_EQ, 250); /* median */
+  tt_str_op(con->client_versions,OP_EQ, "0.1.2.14");
+  tt_str_op(con->server_versions,OP_EQ, "0.1.2.15,0.1.2.16");
   cp = smartlist_join_strings(v2->known_flags, ":", 0, NULL);
-  tt_str_op(cp,==, "Authority:Exit:Fast:Guard:MadeOfCheese:MadeOfTin:"
+  tt_str_op(cp,OP_EQ, "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);
-    tt_str_op(cp,==, "circuitwindow=80:foo=660");
+    tt_str_op(cp,OP_EQ, "circuitwindow=80:foo=660");
     tor_free(cp);
   }
 
-  tt_int_op(4,==, smartlist_len(con->voters)); /*3 voters, 1 legacy key.*/
+  tt_int_op(4,OP_EQ, smartlist_len(con->voters)); /*3 voters, 1 legacy key.*/
   /* The voter id digests should be in this order. */
   tt_assert(memcmp(cert2->cache_info.identity_digest,
                      cert1->cache_info.identity_digest,DIGEST_LEN)<0);
@@ -1994,10 +1994,10 @@ test_a_networkstatus(
   /* 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);
-  tt_int_op(smartlist_len(voter->sigs),==, 0);
+  tt_int_op(smartlist_len(voter->sigs),OP_EQ, 0);
 
   voter = smartlist_get(con->voters, 3);
-  tt_int_op(smartlist_len(voter->sigs),==, 1);
+  tt_int_op(smartlist_len(voter->sigs),OP_EQ, 1);
   sig = smartlist_get(voter->sigs, 0);
   tt_assert(sig->signature);
   tt_assert(!sig->good_signature);
@@ -2047,11 +2047,11 @@ test_a_networkstatus(
     tt_assert(con_md3);
 
     /* All three should have the same digest. */
-    tt_mem_op(&con->digests,==, &con2->digests, sizeof(digests_t));
-    tt_mem_op(&con->digests,==, &con3->digests, sizeof(digests_t));
+    tt_mem_op(&con->digests,OP_EQ, &con2->digests, sizeof(digests_t));
+    tt_mem_op(&con->digests,OP_EQ, &con3->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));
+    tt_mem_op(&con_md->digests,OP_EQ, &con_md2->digests, sizeof(digests_t));
+    tt_mem_op(&con_md->digests,OP_EQ, &con_md3->digests, sizeof(digests_t));
 
     /* Extract a detached signature from con3. */
     detached_text1 = get_detached_sigs(con3, con_md3);
@@ -2061,44 +2061,44 @@ test_a_networkstatus(
     tt_assert(dsig1);
 
     /* Are parsed values as expected? */
-    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);
+    tt_int_op(dsig1->valid_after,OP_EQ, con3->valid_after);
+    tt_int_op(dsig1->fresh_until,OP_EQ, con3->fresh_until);
+    tt_int_op(dsig1->valid_until,OP_EQ, con3->valid_until);
     {
       digests_t *dsig_digests = strmap_get(dsig1->digests, "ns");
       tt_assert(dsig_digests);
-      tt_mem_op(dsig_digests->d[DIGEST_SHA1],==, con3->digests.d[DIGEST_SHA1],
+      tt_mem_op(dsig_digests->d[DIGEST_SHA1],OP_EQ, con3->digests.d[DIGEST_SHA1],
                  DIGEST_LEN);
       dsig_digests = strmap_get(dsig1->digests, "microdesc");
       tt_assert(dsig_digests);
-      tt_mem_op(dsig_digests->d[DIGEST_SHA256],==,
+      tt_mem_op(dsig_digests->d[DIGEST_SHA256],OP_EQ,
                  con_md3->digests.d[DIGEST_SHA256],
                  DIGEST256_LEN);
     }
     {
       smartlist_t *dsig_signatures = strmap_get(dsig1->signatures, "ns");
       tt_assert(dsig_signatures);
-      tt_int_op(1,==, smartlist_len(dsig_signatures));
+      tt_int_op(1,OP_EQ, smartlist_len(dsig_signatures));
       sig = smartlist_get(dsig_signatures, 0);
-      tt_mem_op(sig->identity_digest,==, cert1->cache_info.identity_digest,
+      tt_mem_op(sig->identity_digest,OP_EQ, cert1->cache_info.identity_digest,
                  DIGEST_LEN);
-      tt_int_op(sig->alg,==, DIGEST_SHA1);
+      tt_int_op(sig->alg,OP_EQ, DIGEST_SHA1);
 
       dsig_signatures = strmap_get(dsig1->signatures, "microdesc");
       tt_assert(dsig_signatures);
-      tt_int_op(1,==, smartlist_len(dsig_signatures));
+      tt_int_op(1,OP_EQ, smartlist_len(dsig_signatures));
       sig = smartlist_get(dsig_signatures, 0);
-      tt_mem_op(sig->identity_digest,==, cert1->cache_info.identity_digest,
+      tt_mem_op(sig->identity_digest,OP_EQ, cert1->cache_info.identity_digest,
                  DIGEST_LEN);
-      tt_int_op(sig->alg,==, DIGEST_SHA256);
+      tt_int_op(sig->alg,OP_EQ, DIGEST_SHA256);
     }
 
     /* Try adding it to con2. */
     detached_text2 = get_detached_sigs(con2,con_md2);
-    tt_int_op(1,==, networkstatus_add_detached_signatures(con2, dsig1, "test",
+    tt_int_op(1,OP_EQ, networkstatus_add_detached_signatures(con2, dsig1, "test",
                                                      LOG_INFO, &msg));
     tor_free(detached_text2);
-    tt_int_op(1,==,
+    tt_int_op(1,OP_EQ,
               networkstatus_add_detached_signatures(con_md2, dsig1, "test",
                                                      LOG_INFO, &msg));
     tor_free(detached_text2);
@@ -2114,18 +2114,18 @@ test_a_networkstatus(
         printf("%s\n", hd);
       });
     */
-    tt_int_op(2,==,
+    tt_int_op(2,OP_EQ,
             smartlist_len((smartlist_t*)strmap_get(dsig2->signatures, "ns")));
-    tt_int_op(2,==,
+    tt_int_op(2,OP_EQ,
             smartlist_len((smartlist_t*)strmap_get(dsig2->signatures,
                                                    "microdesc")));
 
     /* Try adding to con2 twice; verify that nothing changes. */
-    tt_int_op(0,==, networkstatus_add_detached_signatures(con2, dsig1, "test",
+    tt_int_op(0,OP_EQ, networkstatus_add_detached_signatures(con2, dsig1, "test",
                                                      LOG_INFO, &msg));
 
     /* Add to con. */
-    tt_int_op(2,==, networkstatus_add_detached_signatures(con, dsig2, "test",
+    tt_int_op(2,OP_EQ, networkstatus_add_detached_signatures(con, dsig2, "test",
                                                      LOG_INFO, &msg));
     /* Check signatures */
     voter = smartlist_get(con->voters, 1);
@@ -2229,7 +2229,7 @@ test_dir_scale_bw(void *testdata)
 
   scale_array_elements_to_u64(vals, 8, &total);
 
-  tt_int_op((int)total, ==, 48);
+  tt_int_op((int)total, OP_EQ, 48);
   total = 0;
   for (i=0; i<8; ++i) {
     total += vals[i].u64;
@@ -2240,7 +2240,7 @@ test_dir_scale_bw(void *testdata)
   for (i=0; i<8; ++i) {
     /* vals[2].u64 is the scaled value of 1.0 */
     double ratio = ((double)vals[i].u64) / vals[2].u64;
-    tt_double_op(fabs(ratio - v[i]), <, .00001);
+    tt_double_op(fabs(ratio - v[i]), OP_LT, .00001);
   }
 
   /* test handling of no entries */
@@ -2291,11 +2291,11 @@ test_dir_random_weighted(void *testdata)
     inp[i].u64 = vals[i];
     total += vals[i];
   }
-  tt_u64_op(total, ==, 45);
+  tt_u64_op(total, OP_EQ, 45);
   for (i=0; i<n; ++i) {
     choice = choose_array_element_by_weight(inp, 10);
-    tt_int_op(choice, >=, 0);
-    tt_int_op(choice, <, 10);
+    tt_int_op(choice, OP_GE, 0);
+    tt_int_op(choice, OP_LT, 10);
     histogram[choice]++;
   }
 
@@ -2308,7 +2308,7 @@ test_dir_random_weighted(void *testdata)
     if (expected)
       frac_diff = (histogram[i] - expected) / ((double)expected);
     else
-      tt_int_op(histogram[i], ==, 0);
+      tt_int_op(histogram[i], OP_EQ, 0);
 
     sq = frac_diff * frac_diff;
     if (sq > max_sq_error)
@@ -2316,12 +2316,12 @@ test_dir_random_weighted(void *testdata)
   }
   /* It should almost always be much much less than this.  If you want to
    * figure out the odds, please feel free. */
-  tt_double_op(max_sq_error, <, .05);
+  tt_double_op(max_sq_error, OP_LT, .05);
 
   /* Now try a singleton; do we choose it? */
   for (i = 0; i < 100; ++i) {
     choice = choose_array_element_by_weight(inp, 1);
-    tt_int_op(choice, ==, 0);
+    tt_int_op(choice, OP_EQ, 0);
   }
 
   /* Now try an array of zeros.  We should choose randomly. */
@@ -2330,8 +2330,8 @@ test_dir_random_weighted(void *testdata)
     inp[i].u64 = 0;
   for (i = 0; i < n; ++i) {
     choice = choose_array_element_by_weight(inp, 5);
-    tt_int_op(choice, >=, 0);
-    tt_int_op(choice, <, 5);
+    tt_int_op(choice, OP_GE, 0);
+    tt_int_op(choice, OP_LT, 5);
     histogram[choice]++;
   }
   /* Now see if we chose things about frequently enough. */
@@ -2347,7 +2347,7 @@ test_dir_random_weighted(void *testdata)
   }
   /* It should almost always be much much less than this.  If you want to
    * figure out the odds, please feel free. */
-  tt_double_op(max_sq_error, <, .05);
+  tt_double_op(max_sq_error, OP_LT, .05);
  done:
   ;
 }
@@ -2546,21 +2546,21 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now)
      * Check the first routerstatus - measured bandwidth below the clip
      * cutoff.
      */
-    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,==,
+    tt_str_op(vrs->version,OP_EQ, "0.1.2.14");
+    tt_int_op(rs->published_on,OP_EQ, now-1500);
+    tt_str_op(rs->nickname,OP_EQ, "router2");
+    tt_mem_op(rs->identity_digest,OP_EQ,
                "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3"
                "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3",
                DIGEST_LEN);
-    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_mem_op(rs->descriptor_digest,OP_EQ, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN);
+    tt_int_op(rs->addr,OP_EQ, 0x99008801);
+    tt_int_op(rs->or_port,OP_EQ, 443);
+    tt_int_op(rs->dir_port,OP_EQ, 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);
+    tt_int_op(rs->bandwidth_kb,OP_EQ, max_unmeasured_bw_kb / 2);
+    tt_int_op(vrs->measured_bw_kb,OP_EQ, 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",
@@ -2570,24 +2570,24 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now)
      * Check the second routerstatus - measured bandwidth above the clip
      * cutoff.
      */
-    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,==,
+    tt_str_op(vrs->version,OP_EQ, "0.2.0.5");
+    tt_int_op(rs->published_on,OP_EQ, now-1000);
+    tt_str_op(rs->nickname,OP_EQ, "router1");
+    tt_mem_op(rs->identity_digest,OP_EQ,
                "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5"
                "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5",
                DIGEST_LEN);
-    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);
+    tt_mem_op(rs->descriptor_digest,OP_EQ, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN);
+    tt_int_op(rs->addr,OP_EQ, 0x99009901);
+    tt_int_op(rs->or_port,OP_EQ, 443);
+    tt_int_op(rs->dir_port,OP_EQ, 0);
     tor_addr_parse(&addr_ipv6, "[1:2:3::4]");
     tt_assert(tor_addr_eq(&rs->ipv6_addr, &addr_ipv6));
-    tt_int_op(rs->ipv6_orport,==, 4711);
+    tt_int_op(rs->ipv6_orport,OP_EQ, 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);
+    tt_int_op(rs->bandwidth_kb,OP_EQ, max_unmeasured_bw_kb * 2);
+    tt_int_op(vrs->measured_bw_kb,OP_EQ, 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",
@@ -2599,8 +2599,8 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now)
      */
     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);
+    tt_int_op(rs->bandwidth_kb,OP_EQ, max_unmeasured_bw_kb * 2);
+    tt_int_op(vrs->measured_bw_kb,OP_EQ, 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",
@@ -2611,8 +2611,8 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now)
      */
     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);
+    tt_int_op(rs->bandwidth_kb,OP_EQ, max_unmeasured_bw_kb / 2);
+    tt_int_op(vrs->measured_bw_kb,OP_EQ, 0);
   } else {
     tt_assert(0);
   }
@@ -2633,7 +2633,7 @@ test_consensus_for_umbw(networkstatus_t *con, time_t now)
   tt_assert(!con->cert);
   // tt_assert(con->consensus_method >= MIN_METHOD_TO_CLIP_UNMEASURED_BW_KB);
   tt_assert(con->consensus_method >= 16);
-  tt_int_op(4,==, smartlist_len(con->routerstatus_list));
+  tt_int_op(4,OP_EQ, smartlist_len(con->routerstatus_list));
   /* There should be four listed routers; all voters saw the same in this */
 
  done:
@@ -2657,11 +2657,11 @@ test_routerstatus_for_umbw(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)) {
-    tt_mem_op(rs->identity_digest,==,
+    tt_mem_op(rs->identity_digest,OP_EQ,
                "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3"
                "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3",
                DIGEST_LEN);
-    tt_mem_op(rs->descriptor_digest,==, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN);
+    tt_mem_op(rs->descriptor_digest,OP_EQ, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN);
     tt_assert(!rs->is_authority);
     tt_assert(!rs->is_exit);
     tt_assert(!rs->is_fast);
@@ -2673,26 +2673,26 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now)
     tt_assert(!rs->is_named);
     /* This one should have measured bandwidth below the clip cutoff */
     tt_assert(rs->has_bandwidth);
-    tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb / 2);
+    tt_int_op(rs->bandwidth_kb,OP_EQ, 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'.  */
-    tt_mem_op(rs->identity_digest,==,
+    tt_mem_op(rs->identity_digest,OP_EQ,
                "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5"
                "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5",
                DIGEST_LEN);
-    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);
+    tt_str_op(rs->nickname,OP_EQ, "router1");
+    tt_mem_op(rs->descriptor_digest,OP_EQ, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN);
+    tt_int_op(rs->published_on,OP_EQ, now-1000);
+    tt_int_op(rs->addr,OP_EQ, 0x99009901);
+    tt_int_op(rs->or_port,OP_EQ, 443);
+    tt_int_op(rs->dir_port,OP_EQ, 0);
     tor_addr_parse(&addr_ipv6, "[1:2:3::4]");
     tt_assert(tor_addr_eq(&rs->ipv6_addr, &addr_ipv6));
-    tt_int_op(rs->ipv6_orport,==, 4711);
+    tt_int_op(rs->ipv6_orport,OP_EQ, 4711);
     tt_assert(!rs->is_authority);
     tt_assert(rs->is_exit);
     tt_assert(rs->is_fast);
@@ -2703,7 +2703,7 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now)
     tt_assert(!rs->is_named);
     /* This one should have measured bandwidth above the clip cutoff */
     tt_assert(rs->has_bandwidth);
-    tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb * 2);
+    tt_int_op(rs->bandwidth_kb,OP_EQ, 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"
@@ -2714,7 +2714,7 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now)
      * and so should be clipped
      */
     tt_assert(rs->has_bandwidth);
-    tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb);
+    tt_int_op(rs->bandwidth_kb,OP_EQ, 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"
@@ -2725,7 +2725,7 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now)
      * and so should not be clipped
      */
     tt_assert(rs->has_bandwidth);
-    tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb / 2);
+    tt_int_op(rs->bandwidth_kb,OP_EQ, max_unmeasured_bw_kb / 2);
     tt_assert(rs->bw_is_unmeasured);
   } else {
     /* Weren't expecting this... */
@@ -2801,7 +2801,7 @@ test_dir_fmt_control_ns(void *arg)
 
   s = networkstatus_getinfo_helper_single(&rs);
   tt_assert(s);
-  tt_str_op(s, ==,
+  tt_str_op(s, OP_EQ,
             "r TetsuoMilk U3RhdGVseSwgcGx1bXAgQnVjayA "
                "TXVsbGlnYW4gY2FtZSB1cCBmcm8 2013-04-02 17:53:18 "
                "32.48.64.80 9001 9002\n"
@@ -2824,16 +2824,16 @@ test_dir_http_handling(void *args)
                            "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);
-  tt_str_op(url,==, "/tor/a/b/c.txt");
+                           &url),OP_EQ, 0);
+  tt_str_op(url,OP_EQ, "/tor/a/b/c.txt");
   tor_free(url);
 
-  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");
+  tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.0\r\n", &url),OP_EQ, 0);
+  tt_str_op(url,OP_EQ, "/tor/a/b/c.txt");
   tor_free(url);
 
-  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");
+  tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.600\r\n", &url),OP_EQ, 0);
+  tt_str_op(url,OP_EQ, "/tor/a/b/c.txt");
   tor_free(url);
 
   /* Should prepend '/tor/' to url if required */
@@ -2841,8 +2841,8 @@ test_dir_http_handling(void *args)
                            "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);
-  tt_str_op(url,==, "/tor/a/b/c.txt");
+                           &url),OP_EQ, 0);
+  tt_str_op(url,OP_EQ, "/tor/a/b/c.txt");
   tor_free(url);
 
   /* Bad headers -- no HTTP/1.x*/
@@ -2850,7 +2850,7 @@ test_dir_http_handling(void *args)
                            "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),OP_EQ, -1);
   tt_assert(!url);
 
   /* Bad headers */
@@ -2858,22 +2858,22 @@ test_dir_http_handling(void *args)
                            "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),OP_EQ, -1);
   tt_assert(!url);
 
-  tt_int_op(parse_http_url("GET /tor/a/b/c.txt", &url),==, -1);
+  tt_int_op(parse_http_url("GET /tor/a/b/c.txt", &url),OP_EQ, -1);
   tt_assert(!url);
 
-  tt_int_op(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),OP_EQ, -1);
   tt_assert(!url);
 
-  tt_int_op(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),OP_EQ, -1);
   tt_assert(!url);
 
-  tt_int_op(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),OP_EQ, -1);
   tt_assert(!url);
 
-  tt_int_op(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),OP_EQ, -1);
   tt_assert(!url);
 
  done:
diff --git a/src/test/test_entrynodes.c b/src/test/test_entrynodes.c
index bddc0f1..eaf2e2d 100644
--- a/src/test/test_entrynodes.c
+++ b/src/test/test_entrynodes.c
@@ -71,15 +71,15 @@ setup_fake_routerlist(void)
   retval = router_load_routers_from_string(TEST_DESCRIPTORS,
                                            NULL, SAVED_IN_JOURNAL,
                                            NULL, 0, NULL);
-  tt_int_op(retval, ==, NUMBER_OF_DESCRIPTORS);
+  tt_int_op(retval, OP_EQ, NUMBER_OF_DESCRIPTORS);
 
   /* Sanity checking of routerlist and nodelist. */
   our_routerlist = router_get_routerlist();
-  tt_int_op(smartlist_len(our_routerlist->routers), ==, NUMBER_OF_DESCRIPTORS);
+  tt_int_op(smartlist_len(our_routerlist->routers), OP_EQ, NUMBER_OF_DESCRIPTORS);
   routerlist_assert_ok(our_routerlist);
 
   our_nodelist = nodelist_get_list();
-  tt_int_op(smartlist_len(our_nodelist), ==, NUMBER_OF_DESCRIPTORS);
+  tt_int_op(smartlist_len(our_nodelist), OP_EQ, NUMBER_OF_DESCRIPTORS);
 
   /* Mark all routers as non-guards but up and running! */
   SMARTLIST_FOREACH_BEGIN(our_nodelist, node_t *, node) {
@@ -163,7 +163,7 @@ test_choose_random_entry_one_possible_guard(void *arg)
 
   /* Pick an entry. Make sure we pick the node we marked as guard. */
   chosen_entry = choose_random_entry(NULL);
-  tt_ptr_op(chosen_entry, ==, the_guard);
+  tt_ptr_op(chosen_entry, OP_EQ, the_guard);
 
  done:
   ;
@@ -189,14 +189,14 @@ populate_live_entry_guards_test_helper(int num_needed)
 
   /* Set NumEntryGuards to the provided number. */
   options->NumEntryGuards = num_needed;
-  tt_int_op(num_needed, ==, decide_num_guards(options, 0));
+  tt_int_op(num_needed, OP_EQ, decide_num_guards(options, 0));
 
   /* The global entry guards smartlist should be empty now. */
-  tt_int_op(smartlist_len(all_entry_guards), ==, 0);
+  tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 0);
 
   /* Walk the nodelist and add all nodes as entry guards. */
   our_nodelist = nodelist_get_list();
-  tt_int_op(smartlist_len(our_nodelist), ==, NUMBER_OF_DESCRIPTORS);
+  tt_int_op(smartlist_len(our_nodelist), OP_EQ, NUMBER_OF_DESCRIPTORS);
 
   SMARTLIST_FOREACH_BEGIN(our_nodelist, const node_t *, node) {
     const node_t *node_tmp;
@@ -205,20 +205,20 @@ populate_live_entry_guards_test_helper(int num_needed)
   } SMARTLIST_FOREACH_END(node);
 
   /* Make sure the nodes were added as entry guards. */
-  tt_int_op(smartlist_len(all_entry_guards), ==, NUMBER_OF_DESCRIPTORS);
+  tt_int_op(smartlist_len(all_entry_guards), OP_EQ, NUMBER_OF_DESCRIPTORS);
 
   /* Ensure that all the possible entry guards are enough to satisfy us. */
-  tt_int_op(smartlist_len(all_entry_guards), >=, num_needed);
+  tt_int_op(smartlist_len(all_entry_guards), OP_GE, num_needed);
 
   /* Walk the entry guard list for some sanity checking */
   SMARTLIST_FOREACH_BEGIN(all_entry_guards, const entry_guard_t *, entry) {
     /* Since we called add_an_entry_guard() with 'for_discovery' being
        False, all guards should have made_contact enabled. */
-    tt_int_op(entry->made_contact, ==, 1);
+    tt_int_op(entry->made_contact, OP_EQ, 1);
 
     /* Since we don't have a routerstatus, all of the entry guards are
        not directory servers. */
-    tt_int_op(entry->is_dir_cache, ==, 0);
+    tt_int_op(entry->is_dir_cache, OP_EQ, 0);
   } SMARTLIST_FOREACH_END(entry);
 
   /* First, try to get some fast guards. This should fail. */
@@ -228,8 +228,8 @@ populate_live_entry_guards_test_helper(int num_needed)
                                       NO_DIRINFO, /* Don't care about DIRINFO*/
                                       0, 0,
                                       1); /* We want fast guard! */
-  tt_int_op(retval, ==, 0);
-  tt_int_op(smartlist_len(live_entry_guards), ==, 0);
+  tt_int_op(retval, OP_EQ, 0);
+  tt_int_op(smartlist_len(live_entry_guards), OP_EQ, 0);
 
   /* Now try to get some stable guards. This should fail too. */
   retval = populate_live_entry_guards(live_entry_guards,
@@ -239,8 +239,8 @@ populate_live_entry_guards_test_helper(int num_needed)
                                       0,
                                       1, /* We want stable guard! */
                                       0);
-  tt_int_op(retval, ==, 0);
-  tt_int_op(smartlist_len(live_entry_guards), ==, 0);
+  tt_int_op(retval, OP_EQ, 0);
+  tt_int_op(smartlist_len(live_entry_guards), OP_EQ, 0);
 
   /* Now try to get any guard we can find. This should succeed. */
   retval = populate_live_entry_guards(live_entry_guards,
@@ -253,8 +253,8 @@ populate_live_entry_guards_test_helper(int num_needed)
      should have added 'num_needed' of them to live_entry_guards.
      'retval' should be 1 since we now have enough live entry guards
      to pick one.  */
-  tt_int_op(retval, ==, 1);
-  tt_int_op(smartlist_len(live_entry_guards), ==, num_needed);
+  tt_int_op(retval, OP_EQ, 1);
+  tt_int_op(smartlist_len(live_entry_guards), OP_EQ, num_needed);
 
  done:
   smartlist_free(live_entry_guards);
@@ -361,7 +361,7 @@ test_entry_guards_parse_state_simple(void *arg)
   (void) arg;
 
   /* The global entry guards smartlist should be empty now. */
-  tt_int_op(smartlist_len(all_entry_guards), ==, 0);
+  tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 0);
 
   { /* Prepare the state entry */
 
@@ -387,34 +387,34 @@ test_entry_guards_parse_state_simple(void *arg)
 
   /* Parse state */
   retval = entry_guards_parse_state(state, 1, &msg);
-  tt_int_op(retval, >=, 0);
+  tt_int_op(retval, OP_GE, 0);
 
   /* Test that the guard was registered.
      We need to re-get the entry guard list since its pointer was
      overwritten in entry_guards_parse_state(). */
   all_entry_guards = get_entry_guards();
-  tt_int_op(smartlist_len(all_entry_guards), ==, 1);
+  tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 1);
 
   { /* Test the entry guard structure */
     char hex_digest[1024];
     char str_time[1024];
 
     const entry_guard_t *e = smartlist_get(all_entry_guards, 0);
-    tt_str_op(e->nickname, ==, nickname); /* Verify nickname */
+    tt_str_op(e->nickname, OP_EQ, nickname); /* Verify nickname */
 
     base16_encode(hex_digest, sizeof(hex_digest),
                   e->identity, DIGEST_LEN);
-    tt_str_op(hex_digest, ==, fpr); /* Verify fingerprint */
+    tt_str_op(hex_digest, OP_EQ, fpr); /* Verify fingerprint */
 
     tt_assert(e->is_dir_cache); /* Verify dirness */
 
-    tt_str_op(e->chosen_by_version, ==, tor_version); /* Verify tor version */
+    tt_str_op(e->chosen_by_version, OP_EQ, tor_version); /* Verify tor version */
 
     tt_assert(e->made_contact); /* All saved guards have been contacted */
 
     tt_assert(e->bad_since); /* Verify bad_since timestamp */
     format_iso_time(str_time, e->bad_since);
-    tt_str_op(str_time, ==, unlisted_since);
+    tt_str_op(str_time, OP_EQ, unlisted_since);
 
     /* The rest should be unset */
     tt_assert(!e->unreachable_since);
@@ -456,7 +456,7 @@ test_entry_guards_parse_state_pathbias(void *arg)
   (void) arg;
 
   /* The global entry guards smartlist should be empty now. */
-  tt_int_op(smartlist_len(all_entry_guards), ==, 0);
+  tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 0);
 
   { /* Prepare the state entry */
 
@@ -492,11 +492,11 @@ test_entry_guards_parse_state_pathbias(void *arg)
 
   /* Parse state */
   retval = entry_guards_parse_state(state, 1, &msg);
-  tt_int_op(retval, >=, 0);
+  tt_int_op(retval, OP_GE, 0);
 
   /* Test that the guard was registered */
   all_entry_guards = get_entry_guards();
-  tt_int_op(smartlist_len(all_entry_guards), ==, 1);
+  tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 1);
 
   { /* Test the path bias of this guard */
     const entry_guard_t *e = smartlist_get(all_entry_guards, 0);
@@ -505,12 +505,12 @@ test_entry_guards_parse_state_pathbias(void *arg)
     tt_assert(!e->can_retry);
 
     /* XXX tt_double_op doesn't support equality. Cast to int for now. */
-    tt_int_op((int)e->circ_attempts, ==, (int)circ_attempts);
-    tt_int_op((int)e->circ_successes, ==, (int)circ_successes);
-    tt_int_op((int)e->successful_circuits_closed, ==, (int)successful_closed);
-    tt_int_op((int)e->timeouts, ==, (int)timeouts);
-    tt_int_op((int)e->collapsed_circuits, ==, (int)collapsed);
-    tt_int_op((int)e->unusable_circuits, ==, (int)unusable);
+    tt_int_op((int)e->circ_attempts, OP_EQ, (int)circ_attempts);
+    tt_int_op((int)e->circ_successes, OP_EQ, (int)circ_successes);
+    tt_int_op((int)e->successful_circuits_closed, OP_EQ, (int)successful_closed);
+    tt_int_op((int)e->timeouts, OP_EQ, (int)timeouts);
+    tt_int_op((int)e->collapsed_circuits, OP_EQ, (int)collapsed);
+    tt_int_op((int)e->unusable_circuits, OP_EQ, (int)unusable);
   }
 
  done:
@@ -537,17 +537,17 @@ test_entry_guards_set_from_config(void *arg)
   retval = routerset_parse(options->EntryNodes,
                            entrynodes_str,
                            "test_entrynodes");
-  tt_int_op(retval, >=, 0);
+  tt_int_op(retval, OP_GE, 0);
 
   /* Read nodes from EntryNodes */
   entry_guards_set_from_config(options);
 
   /* Test that only one guard was added. */
-  tt_int_op(smartlist_len(all_entry_guards), ==, 1);
+  tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 1);
 
   /* Make sure it was the guard we specified. */
   chosen_entry = choose_random_entry(NULL);
-  tt_str_op(chosen_entry->ri->nickname, ==, entrynodes_str);
+  tt_str_op(chosen_entry->ri->nickname, OP_EQ, entrynodes_str);
 
  done:
   routerset_free(options->EntryNodes);
@@ -569,59 +569,59 @@ test_entry_is_time_to_retry(void *arg)
   test_guard->unreachable_since = now - 1;
 
   retval = entry_is_time_to_retry(test_guard,now);
-  tt_int_op(retval,==,1);
+  tt_int_op(retval,OP_EQ,1);
 
   test_guard->unreachable_since = now - (6*60*60 - 1);
   test_guard->last_attempted = now - (60*60 + 1);
 
   retval = entry_is_time_to_retry(test_guard,now);
-  tt_int_op(retval,==,1);
+  tt_int_op(retval,OP_EQ,1);
 
   test_guard->last_attempted = now - (60*60 - 1);
 
   retval = entry_is_time_to_retry(test_guard,now);
-  tt_int_op(retval,==,0);
+  tt_int_op(retval,OP_EQ,0);
 
   test_guard->unreachable_since = now - (6*60*60 + 1);
   test_guard->last_attempted = now - (4*60*60 + 1);
 
   retval = entry_is_time_to_retry(test_guard,now);
-  tt_int_op(retval,==,1);
+  tt_int_op(retval,OP_EQ,1);
 
   test_guard->unreachable_since = now - (3*24*60*60 - 1);
   test_guard->last_attempted = now - (4*60*60 + 1);
 
   retval = entry_is_time_to_retry(test_guard,now);
-  tt_int_op(retval,==,1);
+  tt_int_op(retval,OP_EQ,1);
 
   test_guard->unreachable_since = now - (3*24*60*60 + 1);
   test_guard->last_attempted = now - (18*60*60 + 1);
 
   retval = entry_is_time_to_retry(test_guard,now);
-  tt_int_op(retval,==,1);
+  tt_int_op(retval,OP_EQ,1);
 
   test_guard->unreachable_since = now - (7*24*60*60 - 1);
   test_guard->last_attempted = now - (18*60*60 + 1);
 
   retval = entry_is_time_to_retry(test_guard,now);
-  tt_int_op(retval,==,1);
+  tt_int_op(retval,OP_EQ,1);
 
   test_guard->last_attempted = now - (18*60*60 - 1);
 
   retval = entry_is_time_to_retry(test_guard,now);
-  tt_int_op(retval,==,0);
+  tt_int_op(retval,OP_EQ,0);
 
   test_guard->unreachable_since = now - (7*24*60*60 + 1);
   test_guard->last_attempted = now - (36*60*60 + 1);
 
   retval = entry_is_time_to_retry(test_guard,now);
-  tt_int_op(retval,==,1);
+  tt_int_op(retval,OP_EQ,1);
 
   test_guard->unreachable_since = now - (7*24*60*60 + 1);
   test_guard->last_attempted = now - (36*60*60 + 1);
 
   retval = entry_is_time_to_retry(test_guard,now);
-  tt_int_op(retval,==,1);
+  tt_int_op(retval,OP_EQ,1);
 
  done:
   tor_free(test_guard);
@@ -641,23 +641,23 @@ test_entry_is_live(void *arg)
   (void) arg;
 
   /* The global entry guards smartlist should be empty now. */
-  tt_int_op(smartlist_len(all_entry_guards), ==, 0);
+  tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 0);
 
   /* Walk the nodelist and add all nodes as entry guards. */
   our_nodelist = nodelist_get_list();
-  tt_int_op(smartlist_len(our_nodelist), ==, NUMBER_OF_DESCRIPTORS);
+  tt_int_op(smartlist_len(our_nodelist), OP_EQ, NUMBER_OF_DESCRIPTORS);
 
   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);
     tt_assert(node_tmp);
 
-    tt_int_op(node->is_stable, ==, 0);
-    tt_int_op(node->is_fast, ==, 0);
+    tt_int_op(node->is_stable, OP_EQ, 0);
+    tt_int_op(node->is_fast, OP_EQ, 0);
   } SMARTLIST_FOREACH_END(node);
 
   /* Make sure the nodes were added as entry guards. */
-  tt_int_op(smartlist_len(all_entry_guards), ==, NUMBER_OF_DESCRIPTORS);
+  tt_int_op(smartlist_len(all_entry_guards), OP_EQ, NUMBER_OF_DESCRIPTORS);
 
   /* Now get a random test entry that we will use for this unit test. */
   which_node = 3;  /* (chosen by fair dice roll) */
@@ -681,12 +681,12 @@ test_entry_is_live(void *arg)
   /* Don't impose any restrictions on the node. Should succeed. */
   test_node = entry_is_live(test_entry, 0, &msg);
   tt_assert(test_node);
-  tt_ptr_op(test_node, ==, node_get_by_id(test_entry->identity));
+  tt_ptr_op(test_node, OP_EQ, 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);
   tt_assert(test_node);
-  tt_ptr_op(test_node, ==, node_get_by_id(test_entry->identity));
+  tt_ptr_op(test_node, OP_EQ, node_get_by_id(test_entry->identity));
 
  done:
   ; /* XXX */
diff --git a/src/test/test_extorport.c b/src/test/test_extorport.c
index 4049d6d..c9d8527 100644
--- a/src/test/test_extorport.c
+++ b/src/test/test_extorport.c
@@ -24,35 +24,35 @@ test_ext_or_id_map(void *arg)
   (void)arg;
 
   /* pre-initialization */
-  tt_ptr_op(NULL, ==, connection_or_get_by_ext_or_id("xxxxxxxxxxxxxxxxxxxx"));
+  tt_ptr_op(NULL, OP_EQ, connection_or_get_by_ext_or_id("xxxxxxxxxxxxxxxxxxxx"));
 
   c1 = or_connection_new(CONN_TYPE_EXT_OR, AF_INET);
   c2 = or_connection_new(CONN_TYPE_EXT_OR, AF_INET);
   c3 = or_connection_new(CONN_TYPE_OR, AF_INET);
 
-  tt_ptr_op(c1->ext_or_conn_id, !=, NULL);
-  tt_ptr_op(c2->ext_or_conn_id, !=, NULL);
-  tt_ptr_op(c3->ext_or_conn_id, ==, NULL);
+  tt_ptr_op(c1->ext_or_conn_id, OP_NE, NULL);
+  tt_ptr_op(c2->ext_or_conn_id, OP_NE, NULL);
+  tt_ptr_op(c3->ext_or_conn_id, OP_EQ, NULL);
 
-  tt_ptr_op(c1, ==, connection_or_get_by_ext_or_id(c1->ext_or_conn_id));
-  tt_ptr_op(c2, ==, connection_or_get_by_ext_or_id(c2->ext_or_conn_id));
-  tt_ptr_op(NULL, ==, connection_or_get_by_ext_or_id("xxxxxxxxxxxxxxxxxxxx"));
+  tt_ptr_op(c1, OP_EQ, connection_or_get_by_ext_or_id(c1->ext_or_conn_id));
+  tt_ptr_op(c2, OP_EQ, connection_or_get_by_ext_or_id(c2->ext_or_conn_id));
+  tt_ptr_op(NULL, OP_EQ, connection_or_get_by_ext_or_id("xxxxxxxxxxxxxxxxxxxx"));
 
   idp = tor_memdup(c2->ext_or_conn_id, EXT_OR_CONN_ID_LEN);
 
   /* Give c2 a new ID. */
   connection_or_set_ext_or_identifier(c2);
-  tt_mem_op(idp, !=, c2->ext_or_conn_id, EXT_OR_CONN_ID_LEN);
+  tt_mem_op(idp, OP_NE, 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));
 
-  tt_ptr_op(NULL, ==, connection_or_get_by_ext_or_id(idp));
-  tt_ptr_op(c2, ==, connection_or_get_by_ext_or_id(idp2));
+  tt_ptr_op(NULL, OP_EQ, connection_or_get_by_ext_or_id(idp));
+  tt_ptr_op(c2, OP_EQ, connection_or_get_by_ext_or_id(idp2));
 
   /* Now remove it. */
   connection_or_remove_from_ext_or_id_map(c2);
-  tt_ptr_op(NULL, ==, connection_or_get_by_ext_or_id(idp));
-  tt_ptr_op(NULL, ==, connection_or_get_by_ext_or_id(idp2));
+  tt_ptr_op(NULL, OP_EQ, connection_or_get_by_ext_or_id(idp));
+  tt_ptr_op(NULL, OP_EQ, connection_or_get_by_ext_or_id(idp2));
 
  done:
   if (c1)
@@ -112,33 +112,33 @@ test_ext_or_write_command(void *arg)
 
   /* Length too long */
   tt_int_op(connection_write_ext_or_command(TO_CONN(c1), 100, "X", 100000),
-            <, 0);
+            OP_LT, 0);
 
   /* Empty command */
   tt_int_op(connection_write_ext_or_command(TO_CONN(c1), 0x99, NULL, 0),
-            ==, 0);
+            OP_EQ, 0);
   cp = buf_get_contents(TO_CONN(c1)->outbuf, &sz);
-  tt_int_op(sz, ==, 4);
-  tt_mem_op(cp, ==, "\x00\x99\x00\x00", 4);
+  tt_int_op(sz, OP_EQ, 4);
+  tt_mem_op(cp, OP_EQ, "\x00\x99\x00\x00", 4);
   tor_free(cp);
 
   /* Medium command. */
   tt_int_op(connection_write_ext_or_command(TO_CONN(c1), 0x99,
-                                            "Wai\0Hello", 9), ==, 0);
+                                            "Wai\0Hello", 9), OP_EQ, 0);
   cp = buf_get_contents(TO_CONN(c1)->outbuf, &sz);
-  tt_int_op(sz, ==, 13);
-  tt_mem_op(cp, ==, "\x00\x99\x00\x09Wai\x00Hello", 13);
+  tt_int_op(sz, OP_EQ, 13);
+  tt_mem_op(cp, OP_EQ, "\x00\x99\x00\x09Wai\x00Hello", 13);
   tor_free(cp);
 
   /* Long command */
   buf = tor_malloc(65535);
   memset(buf, 'x', 65535);
   tt_int_op(connection_write_ext_or_command(TO_CONN(c1), 0xf00d,
-                                            buf, 65535), ==, 0);
+                                            buf, 65535), OP_EQ, 0);
   cp = buf_get_contents(TO_CONN(c1)->outbuf, &sz);
-  tt_int_op(sz, ==, 65539);
-  tt_mem_op(cp, ==, "\xf0\x0d\xff\xff", 4);
-  tt_mem_op(cp+4, ==, buf, 65535);
+  tt_int_op(sz, OP_EQ, 65539);
+  tt_mem_op(cp, OP_EQ, "\xf0\x0d\xff\xff", 4);
+  tt_mem_op(cp+4, OP_EQ, buf, 65535);
   tor_free(cp);
 
  done:
@@ -175,7 +175,7 @@ test_ext_or_init_auth(void *arg)
   tor_free(options->DataDirectory);
   options->DataDirectory = tor_strdup("foo");
   cp = get_ext_or_auth_cookie_file_name();
-  tt_str_op(cp, ==, "foo"PATH_SEPARATOR"extended_orport_auth_cookie");
+  tt_str_op(cp, OP_EQ, "foo"PATH_SEPARATOR"extended_orport_auth_cookie");
   tor_free(cp);
 
   /* Shouldn't be initialized already, or our tests will be a bit
@@ -187,30 +187,30 @@ test_ext_or_init_auth(void *arg)
   fn = get_fname("ext_cookie_file");
   options->ExtORPortCookieAuthFile = tor_strdup(fn);
   cp = get_ext_or_auth_cookie_file_name();
-  tt_str_op(cp, ==, fn);
+  tt_str_op(cp, OP_EQ, fn);
   tor_free(cp);
 
   /* Test the initialization function with a broken
      write_bytes_to_file(). See if the problem is handled properly. */
   MOCK(write_bytes_to_file, write_bytes_to_file_fail);
-  tt_int_op(-1, ==, init_ext_or_cookie_authentication(1));
-  tt_int_op(ext_or_auth_cookie_is_set, ==, 0);
+  tt_int_op(-1, OP_EQ, init_ext_or_cookie_authentication(1));
+  tt_int_op(ext_or_auth_cookie_is_set, OP_EQ, 0);
   UNMOCK(write_bytes_to_file);
 
   /* Now do the actual initialization. */
-  tt_int_op(0, ==, init_ext_or_cookie_authentication(1));
-  tt_int_op(ext_or_auth_cookie_is_set, ==, 1);
+  tt_int_op(0, OP_EQ, init_ext_or_cookie_authentication(1));
+  tt_int_op(ext_or_auth_cookie_is_set, OP_EQ, 1);
   cp = read_file_to_str(fn, RFTS_BIN, &st);
-  tt_ptr_op(cp, !=, NULL);
-  tt_u64_op((uint64_t)st.st_size, ==, 64);
-  tt_mem_op(cp,==, "! Extended ORPort Auth Cookie !\x0a", 32);
-  tt_mem_op(cp+32,==, ext_or_auth_cookie, 32);
+  tt_ptr_op(cp, OP_NE, NULL);
+  tt_u64_op((uint64_t)st.st_size, OP_EQ, 64);
+  tt_mem_op(cp,OP_EQ, "! Extended ORPort Auth Cookie !\x0a", 32);
+  tt_mem_op(cp+32,OP_EQ, ext_or_auth_cookie, 32);
   memcpy(cookie0, 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));
-  tt_mem_op(cookie0,==, ext_or_auth_cookie, 32);
+  tt_int_op(0, OP_EQ, init_ext_or_cookie_authentication(1));
+  tt_mem_op(cookie0,OP_EQ, ext_or_auth_cookie, 32);
 
  done:
   tor_free(cp);
@@ -237,8 +237,8 @@ test_ext_or_cookie_auth(void *arg)
 
   (void)arg;
 
-  tt_int_op(strlen(client_hash_input), ==, 46+32+32);
-  tt_int_op(strlen(server_hash_input), ==, 46+32+32);
+  tt_int_op(strlen(client_hash_input), OP_EQ, 46+32+32);
+  tt_int_op(strlen(server_hash_input), OP_EQ, 46+32+32);
 
   ext_or_auth_cookie = tor_malloc_zero(32);
   memcpy(ext_or_auth_cookie, "s beside you? When I count, ther", 32);
@@ -258,20 +258,20 @@ test_ext_or_cookie_auth(void *arg)
    */
 
   /* Wrong length */
-  tt_int_op(-1, ==,
+  tt_int_op(-1, OP_EQ,
             handle_client_auth_nonce(client_nonce, 33, &client_hash, &reply,
                                      &reply_len));
-  tt_int_op(-1, ==,
+  tt_int_op(-1, OP_EQ,
             handle_client_auth_nonce(client_nonce, 31, &client_hash, &reply,
                                      &reply_len));
 
   /* Now let's try this for real! */
-  tt_int_op(0, ==,
+  tt_int_op(0, OP_EQ,
             handle_client_auth_nonce(client_nonce, 32, &client_hash, &reply,
                                      &reply_len));
-  tt_int_op(reply_len, ==, 64);
-  tt_ptr_op(reply, !=, NULL);
-  tt_ptr_op(client_hash, !=, NULL);
+  tt_int_op(reply_len, OP_EQ, 64);
+  tt_ptr_op(reply, OP_NE, NULL);
+  tt_ptr_op(client_hash, OP_NE, NULL);
   /* Fill in the server nonce into the hash inputs... */
   memcpy(server_hash_input+46+32, reply+32, 32);
   memcpy(client_hash_input+46+32, reply+32, 32);
@@ -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);
-  tt_mem_op(hmac1,==, reply, 32);
-  tt_mem_op(hmac2,==, client_hash, 32);
+  tt_mem_op(hmac1,OP_EQ, reply, 32);
+  tt_mem_op(hmac2,OP_EQ, client_hash, 32);
 
   /* Now do it again and make sure that the results are *different* */
-  tt_int_op(0, ==,
+  tt_int_op(0, OP_EQ,
             handle_client_auth_nonce(client_nonce, 32, &client_hash2, &reply2,
                                      &reply_len));
-  tt_mem_op(reply2,!=, reply, reply_len);
-  tt_mem_op(client_hash2,!=, client_hash, 32);
+  tt_mem_op(reply2,OP_NE, reply, reply_len);
+  tt_mem_op(client_hash2,OP_NE, 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);
-  tt_mem_op(hmac1,==, reply2, 32);
-  tt_mem_op(hmac2,==, client_hash2, 32);
+  tt_mem_op(hmac1,OP_EQ, reply2, 32);
+  tt_mem_op(hmac2,OP_EQ, client_hash2, 32);
 
  done:
   tor_free(reply);
@@ -334,12 +334,12 @@ test_ext_or_cookie_auth_testvec(void *arg)
 
   MOCK(crypto_rand, crypto_rand_return_tse_str);
 
-  tt_int_op(0, ==,
+  tt_int_op(0, OP_EQ,
             handle_client_auth_nonce(client_nonce, 32, &client_hash, &reply,
                                      &reply_len));
-  tt_ptr_op(reply, !=, NULL );
-  tt_uint_op(reply_len, ==, 64);
-  tt_mem_op(reply+32,==, "te road There is always another ", 32);
+  tt_ptr_op(reply, OP_NE, NULL );
+  tt_uint_op(reply_len, OP_EQ, 64);
+  tt_mem_op(reply+32,OP_EQ, "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 ");
@@ -402,11 +402,11 @@ handshake_start(or_connection_t *conn, int receiving)
   } while (0)
 #define CONTAINS(s,n)                                           \
   do {                                                          \
-    tt_int_op((n), <=, sizeof(b));                              \
-    tt_int_op(buf_datalen(TO_CONN(conn)->outbuf), ==, (n));     \
+    tt_int_op((n), OP_LE, sizeof(b));                              \
+    tt_int_op(buf_datalen(TO_CONN(conn)->outbuf), OP_EQ, (n));     \
     if ((n)) {                                                  \
       fetch_from_buf(b, (n), TO_CONN(conn)->outbuf);            \
-      tt_mem_op(b, ==, (s), (n));                               \
+      tt_mem_op(b, OP_EQ, (s), (n));                               \
     }                                                           \
   } while (0)
 
@@ -416,14 +416,14 @@ do_ext_or_handshake(or_connection_t *conn)
 {
   char b[256];
 
-  tt_int_op(0, ==, connection_ext_or_start_auth(conn));
+  tt_int_op(0, OP_EQ, connection_ext_or_start_auth(conn));
   CONTAINS("\x01\x00", 2);
   WRITE("\x01", 1);
   WRITE("But when I look ahead up the whi", 32);
   MOCK(crypto_rand, crypto_rand_return_tse_str);
-  tt_int_op(0, ==, connection_ext_or_process_inbuf(conn));
+  tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn));
   UNMOCK(crypto_rand);
-  tt_int_op(TO_CONN(conn)->state, ==, EXT_OR_CONN_STATE_AUTH_WAIT_CLIENT_HASH);
+  tt_int_op(TO_CONN(conn)->state, OP_EQ, EXT_OR_CONN_STATE_AUTH_WAIT_CLIENT_HASH);
   CONTAINS("\xec\x80\xed\x6e\x54\x6d\x3b\x36\xfd\xfc\x22\xfe\x13\x15\x41\x6b"
            "\x02\x9f\x1a\xde\x76\x10\xd9\x10\x87\x8b\x62\xee\xb7\x40\x38\x21"
            "te road There is always another ", 64);
@@ -431,10 +431,10 @@ do_ext_or_handshake(or_connection_t *conn)
   WRITE("\xab\x39\x17\x32\xdd\x2e\xd9\x68\xcd\x40\xc0\x87\xd1\xb1\xf2\x5b"
         "\x33\xb3\xcd\x77\xff\x79\xbd\x80\xc2\x07\x4b\xbf\x43\x81\x19\xa2",
         32);
-  tt_int_op(0, ==, connection_ext_or_process_inbuf(conn));
+  tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn));
   CONTAINS("\x01", 1);
   tt_assert(! TO_CONN(conn)->marked_for_close);
-  tt_int_op(TO_CONN(conn)->state, ==, EXT_OR_CONN_STATE_OPEN);
+  tt_int_op(TO_CONN(conn)->state, OP_EQ, EXT_OR_CONN_STATE_OPEN);
 
  done: ;
 }
@@ -456,14 +456,14 @@ test_ext_or_handshake(void *arg)
   init_connection_lists();
 
   conn = or_connection_new(CONN_TYPE_EXT_OR, AF_INET);
-  tt_int_op(0, ==, connection_ext_or_start_auth(conn));
+  tt_int_op(0, OP_EQ, connection_ext_or_start_auth(conn));
   /* The server starts by telling us about the one supported authtype. */
   CONTAINS("\x01\x00", 2);
   /* Say the client hasn't responded yet. */
-  tt_int_op(0, ==, connection_ext_or_process_inbuf(conn));
+  tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn));
   /* Let's say the client replies badly. */
   WRITE("\x99", 1);
-  tt_int_op(-1, ==, connection_ext_or_process_inbuf(conn));
+  tt_int_op(-1, OP_EQ, connection_ext_or_process_inbuf(conn));
   CONTAINS("", 0);
   tt_assert(TO_CONN(conn)->marked_for_close);
   close_closeable_connections();
@@ -471,23 +471,23 @@ test_ext_or_handshake(void *arg)
 
   /* Okay, try again. */
   conn = or_connection_new(CONN_TYPE_EXT_OR, AF_INET);
-  tt_int_op(0, ==, connection_ext_or_start_auth(conn));
+  tt_int_op(0, OP_EQ, connection_ext_or_start_auth(conn));
   CONTAINS("\x01\x00", 2);
   /* Let's say the client replies sensibly this time. "Yes, AUTHTYPE_COOKIE
    * sounds delicious. Let's have some of that!" */
   WRITE("\x01", 1);
   /* Let's say that the client also sends part of a nonce. */
   WRITE("But when I look ", 16);
-  tt_int_op(0, ==, connection_ext_or_process_inbuf(conn));
+  tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn));
   CONTAINS("", 0);
-  tt_int_op(TO_CONN(conn)->state, ==,
+  tt_int_op(TO_CONN(conn)->state, OP_EQ,
             EXT_OR_CONN_STATE_AUTH_WAIT_CLIENT_NONCE);
   /* Pump it again. Nothing should happen. */
-  tt_int_op(0, ==, connection_ext_or_process_inbuf(conn));
+  tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn));
   /* send the rest of the nonce. */
   WRITE("ahead up the whi", 16);
   MOCK(crypto_rand, crypto_rand_return_tse_str);
-  tt_int_op(0, ==, connection_ext_or_process_inbuf(conn));
+  tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn));
   UNMOCK(crypto_rand);
   /* We should get the right reply from the server. */
   CONTAINS("\xec\x80\xed\x6e\x54\x6d\x3b\x36\xfd\xfc\x22\xfe\x13\x15\x41\x6b"
@@ -496,7 +496,7 @@ test_ext_or_handshake(void *arg)
   /* Send the wrong response. */
   WRITE("not with a bang but a whimper...", 32);
   MOCK(control_event_bootstrap_problem, ignore_bootstrap_problem);
-  tt_int_op(-1, ==, connection_ext_or_process_inbuf(conn));
+  tt_int_op(-1, OP_EQ, connection_ext_or_process_inbuf(conn));
   CONTAINS("\x00", 1);
   tt_assert(TO_CONN(conn)->marked_for_close);
   /* XXXX Hold-open-until-flushed. */
@@ -515,32 +515,32 @@ test_ext_or_handshake(void *arg)
   /* Now let's run through some messages. */
   /* First let's send some junk and make sure it's ignored. */
   WRITE("\xff\xf0\x00\x03""ABC", 7);
-  tt_int_op(0, ==, connection_ext_or_process_inbuf(conn));
+  tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn));
   CONTAINS("", 0);
   /* Now let's send a USERADDR command. */
   WRITE("\x00\x01\x00\x0c""1.2.3.4:5678", 16);
-  tt_int_op(0, ==, connection_ext_or_process_inbuf(conn));
-  tt_int_op(TO_CONN(conn)->port, ==, 5678);
-  tt_int_op(tor_addr_to_ipv4h(&TO_CONN(conn)->addr), ==, 0x01020304);
+  tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn));
+  tt_int_op(TO_CONN(conn)->port, OP_EQ, 5678);
+  tt_int_op(tor_addr_to_ipv4h(&TO_CONN(conn)->addr), OP_EQ, 0x01020304);
   /* Now let's send a TRANSPORT command. */
   WRITE("\x00\x02\x00\x07""rfc1149", 11);
-  tt_int_op(0, ==, connection_ext_or_process_inbuf(conn));
-  tt_ptr_op(NULL, !=, conn->ext_or_transport);
-  tt_str_op("rfc1149", ==, conn->ext_or_transport);
-  tt_int_op(is_reading,==,1);
-  tt_int_op(TO_CONN(conn)->state, ==, EXT_OR_CONN_STATE_OPEN);
+  tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn));
+  tt_ptr_op(NULL, OP_NE, conn->ext_or_transport);
+  tt_str_op("rfc1149", OP_EQ, conn->ext_or_transport);
+  tt_int_op(is_reading,OP_EQ,1);
+  tt_int_op(TO_CONN(conn)->state, OP_EQ, EXT_OR_CONN_STATE_OPEN);
   /* DONE */
   WRITE("\x00\x00\x00\x00", 4);
-  tt_int_op(0, ==, connection_ext_or_process_inbuf(conn));
-  tt_int_op(TO_CONN(conn)->state, ==, EXT_OR_CONN_STATE_FLUSHING);
-  tt_int_op(is_reading,==,0);
+  tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn));
+  tt_int_op(TO_CONN(conn)->state, OP_EQ, EXT_OR_CONN_STATE_FLUSHING);
+  tt_int_op(is_reading,OP_EQ,0);
   CONTAINS("\x10\x00\x00\x00", 4);
-  tt_int_op(handshake_start_called,==,0);
-  tt_int_op(0, ==, connection_ext_or_finished_flushing(conn));
-  tt_int_op(is_reading,==,1);
-  tt_int_op(handshake_start_called,==,1);
-  tt_int_op(TO_CONN(conn)->type, ==, CONN_TYPE_OR);
-  tt_int_op(TO_CONN(conn)->state, ==, 0);
+  tt_int_op(handshake_start_called,OP_EQ,0);
+  tt_int_op(0, OP_EQ, connection_ext_or_finished_flushing(conn));
+  tt_int_op(is_reading,OP_EQ,1);
+  tt_int_op(handshake_start_called,OP_EQ,1);
+  tt_int_op(TO_CONN(conn)->type, OP_EQ, CONN_TYPE_OR);
+  tt_int_op(TO_CONN(conn)->state, OP_EQ, 0);
   close_closeable_connections();
   conn = NULL;
 
@@ -551,7 +551,7 @@ test_ext_or_handshake(void *arg)
   /* USERADDR command with an extra NUL byte */
   WRITE("\x00\x01\x00\x0d""1.2.3.4:5678\x00", 17);
   MOCK(control_event_bootstrap_problem, ignore_bootstrap_problem);
-  tt_int_op(-1, ==, connection_ext_or_process_inbuf(conn));
+  tt_int_op(-1, OP_EQ, connection_ext_or_process_inbuf(conn));
   CONTAINS("", 0);
   tt_assert(TO_CONN(conn)->marked_for_close);
   close_closeable_connections();
@@ -564,7 +564,7 @@ test_ext_or_handshake(void *arg)
   /* TRANSPORT command with an extra NUL byte */
   WRITE("\x00\x02\x00\x08""rfc1149\x00", 12);
   MOCK(control_event_bootstrap_problem, ignore_bootstrap_problem);
-  tt_int_op(-1, ==, connection_ext_or_process_inbuf(conn));
+  tt_int_op(-1, OP_EQ, connection_ext_or_process_inbuf(conn));
   CONTAINS("", 0);
   tt_assert(TO_CONN(conn)->marked_for_close);
   close_closeable_connections();
@@ -578,7 +578,7 @@ test_ext_or_handshake(void *arg)
      C-identifier) */
   WRITE("\x00\x02\x00\x07""rf*1149", 11);
   MOCK(control_event_bootstrap_problem, ignore_bootstrap_problem);
-  tt_int_op(-1, ==, connection_ext_or_process_inbuf(conn));
+  tt_int_op(-1, OP_EQ, connection_ext_or_process_inbuf(conn));
   CONTAINS("", 0);
   tt_assert(TO_CONN(conn)->marked_for_close);
   close_closeable_connections();
diff --git a/src/test/test_hs.c b/src/test/test_hs.c
index c482001..2db88a4 100644
--- a/src/test/test_hs.c
+++ b/src/test/test_hs.c
@@ -85,7 +85,7 @@ test_hs_desc_event(void *arg)
   expected_msg = "650 HS_DESC REQUESTED "STR_HS_ADDR" NO_AUTH "\
                   STR_HSDIR_EXIST_LONGNAME" "STR_HS_ID"\r\n";
   tt_assert(received_msg);
-  tt_str_op(received_msg,==, expected_msg);
+  tt_str_op(received_msg,OP_EQ, expected_msg);
   tor_free(received_msg);
 
   /* test received event */
@@ -94,7 +94,7 @@ test_hs_desc_event(void *arg)
   expected_msg = "650 HS_DESC RECEIVED "STR_HS_ADDR" BASIC_AUTH "\
                   STR_HSDIR_EXIST_LONGNAME"\r\n";
   tt_assert(received_msg);
-  tt_str_op(received_msg,==, expected_msg);
+  tt_str_op(received_msg,OP_EQ, expected_msg);
   tor_free(received_msg);
 
   /* test failed event */
@@ -103,7 +103,7 @@ test_hs_desc_event(void *arg)
   expected_msg = "650 HS_DESC FAILED "STR_HS_ADDR" STEALTH_AUTH "\
                   STR_HSDIR_NONE_EXIST_LONGNAME"\r\n";
   tt_assert(received_msg);
-  tt_str_op(received_msg,==, expected_msg);
+  tt_str_op(received_msg,OP_EQ, expected_msg);
   tor_free(received_msg);
 
   /* test invalid auth type */
@@ -112,7 +112,7 @@ test_hs_desc_event(void *arg)
   expected_msg = "650 HS_DESC FAILED "STR_HS_ADDR" UNKNOWN "\
                   STR_HSDIR_EXIST_LONGNAME"\r\n";
   tt_assert(received_msg);
-  tt_str_op(received_msg,==, expected_msg);
+  tt_str_op(received_msg,OP_EQ, expected_msg);
   tor_free(received_msg);
 
  done:
diff --git a/src/test/test_introduce.c b/src/test/test_introduce.c
index 0febd59..fe8ffbf 100644
--- a/src/test/test_introduce.c
+++ b/src/test/test_introduce.c
@@ -310,7 +310,7 @@ do_parse_test(uint8_t *plaintext, size_t plaintext_len, int phase)
   parsed_req = rend_service_begin_parse_intro(cell, cell_len, 2, &err_msg);
   tt_assert(parsed_req);
   tt_assert(!err_msg);
-  tt_mem_op(parsed_req->pk,==, digest, DIGEST_LEN);
+  tt_mem_op(parsed_req->pk,OP_EQ, digest, DIGEST_LEN);
   tt_assert(parsed_req->ciphertext);
   tt_assert(parsed_req->ciphertext_len > 0);
 
diff --git a/src/test/test_logging.c b/src/test/test_logging.c
index 9d9cbae..17f1ed5 100644
--- a/src/test/test_logging.c
+++ b/src/test/test_logging.c
@@ -22,8 +22,8 @@ test_get_sigsafe_err_fds(void *arg)
   init_logging(1);
 
   n = tor_log_get_sigsafe_err_fds(&fds);
-  tt_int_op(n, ==, 1);
-  tt_int_op(fds[0], ==, STDERR_FILENO);
+  tt_int_op(n, OP_EQ, 1);
+  tt_int_op(fds[0], OP_EQ, STDERR_FILENO);
 
   set_log_severity_config(LOG_WARN, LOG_ERR, &include_bug);
   set_log_severity_config(LOG_WARN, LOG_ERR, &no_bug);
@@ -40,26 +40,26 @@ test_get_sigsafe_err_fds(void *arg)
   tor_log_update_sigsafe_err_fds();
 
   n = tor_log_get_sigsafe_err_fds(&fds);
-  tt_int_op(n, ==, 2);
-  tt_int_op(fds[0], ==, STDERR_FILENO);
-  tt_int_op(fds[1], ==, 3);
+  tt_int_op(n, OP_EQ, 2);
+  tt_int_op(fds[0], OP_EQ, STDERR_FILENO);
+  tt_int_op(fds[1], OP_EQ, 3);
 
   /* Allow STDOUT to replace STDERR. */
   add_stream_log(&include_bug, "dummy-4", STDOUT_FILENO);
   tor_log_update_sigsafe_err_fds();
   n = tor_log_get_sigsafe_err_fds(&fds);
-  tt_int_op(n, ==, 2);
-  tt_int_op(fds[0], ==, 3);
-  tt_int_op(fds[1], ==, STDOUT_FILENO);
+  tt_int_op(n, OP_EQ, 2);
+  tt_int_op(fds[0], OP_EQ, 3);
+  tt_int_op(fds[1], OP_EQ, STDOUT_FILENO);
 
   /* But don't allow it to replace explicit STDERR. */
   add_stream_log(&include_bug, "dummy-5", STDERR_FILENO);
   tor_log_update_sigsafe_err_fds();
   n = tor_log_get_sigsafe_err_fds(&fds);
-  tt_int_op(n, ==, 3);
-  tt_int_op(fds[0], ==, STDERR_FILENO);
-  tt_int_op(fds[1], ==, STDOUT_FILENO);
-  tt_int_op(fds[2], ==, 3);
+  tt_int_op(n, OP_EQ, 3);
+  tt_int_op(fds[0], OP_EQ, STDERR_FILENO);
+  tt_int_op(fds[1], OP_EQ, STDOUT_FILENO);
+  tt_int_op(fds[2], OP_EQ, 3);
 
   /* Don't overflow the array. */
   {
@@ -70,7 +70,7 @@ test_get_sigsafe_err_fds(void *arg)
   }
   tor_log_update_sigsafe_err_fds();
   n = tor_log_get_sigsafe_err_fds(&fds);
-  tt_int_op(n, ==, 8);
+  tt_int_op(n, OP_EQ, 8);
 
  done:
   ;
@@ -109,7 +109,7 @@ test_sigsafe_err(void *arg)
 
   tt_assert(content != NULL);
   tor_split_lines(lines, content, (int)strlen(content));
-  tt_int_op(smartlist_len(lines), >=, 5);
+  tt_int_op(smartlist_len(lines), OP_GE, 5);
 
   if (strstr(smartlist_get(lines, 0), "opening new log file"))
     smartlist_del_keeporder(lines, 0);
@@ -119,7 +119,7 @@ test_sigsafe_err(void *arg)
   tt_assert(!strcmpstart(smartlist_get(lines, 2), "Minimal."));
   /* Next line is blank. */
   tt_assert(!strcmpstart(smartlist_get(lines, 3), "=============="));
-  tt_str_op(smartlist_get(lines, 4), ==,
+  tt_str_op(smartlist_get(lines, 4), OP_EQ,
             "Testing any attempt to manually log from a signal.");
 
  done:
diff --git a/src/test/test_microdesc.c b/src/test/test_microdesc.c
index aa4bdf2..4a7c29b 100644
--- a/src/test/test_microdesc.c
+++ b/src/test/test_microdesc.c
@@ -75,9 +75,9 @@ test_md_cache(void *data)
   tor_free(options->DataDirectory);
   options->DataDirectory = tor_strdup(get_fname("md_datadir_test"));
 #ifdef _WIN32
-  tt_int_op(0, ==, mkdir(options->DataDirectory));
+  tt_int_op(0, OP_EQ, mkdir(options->DataDirectory));
 #else
-  tt_int_op(0, ==, mkdir(options->DataDirectory, 0700));
+  tt_int_op(0, OP_EQ, mkdir(options->DataDirectory, 0700));
 #endif
 
   tt_assert(!strcmpstart(test_md3_noannotation, "onion-key"));
@@ -91,7 +91,7 @@ test_md_cache(void *data)
 
   added = microdescs_add_to_cache(mc, test_md1, NULL, SAVED_NOWHERE, 0,
                                   time1, NULL);
-  tt_int_op(1, ==, smartlist_len(added));
+  tt_int_op(1, OP_EQ, smartlist_len(added));
   md1 = smartlist_get(added, 0);
   smartlist_free(added);
   added = NULL;
@@ -100,7 +100,7 @@ test_md_cache(void *data)
   added = microdescs_add_to_cache(mc, test_md2, NULL, SAVED_NOWHERE, 0,
                                   time2, wanted);
   /* Should fail, since we didn't list test_md2's digest in wanted */
-  tt_int_op(0, ==, smartlist_len(added));
+  tt_int_op(0, OP_EQ, smartlist_len(added));
   smartlist_free(added);
   added = NULL;
 
@@ -109,75 +109,75 @@ test_md_cache(void *data)
   added = microdescs_add_to_cache(mc, test_md2, NULL, SAVED_NOWHERE, 0,
                                   time2, wanted);
   /* Now it can work. md2 should have been added */
-  tt_int_op(1, ==, smartlist_len(added));
+  tt_int_op(1, OP_EQ, smartlist_len(added));
   md2 = smartlist_get(added, 0);
   /* And it should have gotten removed from 'wanted' */
-  tt_int_op(smartlist_len(wanted), ==, 1);
-  tt_mem_op(smartlist_get(wanted, 0), ==, d3, DIGEST256_LEN);
+  tt_int_op(smartlist_len(wanted), OP_EQ, 1);
+  tt_mem_op(smartlist_get(wanted, 0), OP_EQ, d3, DIGEST256_LEN);
   smartlist_free(added);
   added = NULL;
 
   added = microdescs_add_to_cache(mc, test_md3, NULL,
                                   SAVED_NOWHERE, 0, -1, NULL);
   /* Must fail, since SAVED_NOWHERE precludes annotations */
-  tt_int_op(0, ==, smartlist_len(added));
+  tt_int_op(0, OP_EQ, smartlist_len(added));
   smartlist_free(added);
   added = NULL;
 
   added = microdescs_add_to_cache(mc, test_md3_noannotation, NULL,
                                   SAVED_NOWHERE, 0, time3, NULL);
   /* Now it can work */
-  tt_int_op(1, ==, smartlist_len(added));
+  tt_int_op(1, OP_EQ, smartlist_len(added));
   md3 = smartlist_get(added, 0);
   smartlist_free(added);
   added = NULL;
 
   /* Okay.  We added 1...3.  Let's poke them to see how they look, and make
    * sure they're really in the journal. */
-  tt_ptr_op(md1, ==, microdesc_cache_lookup_by_digest256(mc, d1));
-  tt_ptr_op(md2, ==, microdesc_cache_lookup_by_digest256(mc, d2));
-  tt_ptr_op(md3, ==, microdesc_cache_lookup_by_digest256(mc, d3));
-
-  tt_int_op(md1->last_listed, ==, time1);
-  tt_int_op(md2->last_listed, ==, time2);
-  tt_int_op(md3->last_listed, ==, time3);
-
-  tt_int_op(md1->saved_location, ==, SAVED_IN_JOURNAL);
-  tt_int_op(md2->saved_location, ==, SAVED_IN_JOURNAL);
-  tt_int_op(md3->saved_location, ==, SAVED_IN_JOURNAL);
-
-  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));
-  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,
+  tt_ptr_op(md1, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d1));
+  tt_ptr_op(md2, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d2));
+  tt_ptr_op(md3, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d3));
+
+  tt_int_op(md1->last_listed, OP_EQ, time1);
+  tt_int_op(md2->last_listed, OP_EQ, time2);
+  tt_int_op(md3->last_listed, OP_EQ, time3);
+
+  tt_int_op(md1->saved_location, OP_EQ, SAVED_IN_JOURNAL);
+  tt_int_op(md2->saved_location, OP_EQ, SAVED_IN_JOURNAL);
+  tt_int_op(md3->saved_location, OP_EQ, SAVED_IN_JOURNAL);
+
+  tt_int_op(md1->bodylen, OP_EQ, strlen(test_md1));
+  tt_int_op(md2->bodylen, OP_EQ, strlen(test_md2));
+  tt_int_op(md3->bodylen, OP_EQ, strlen(test_md3_noannotation));
+  tt_mem_op(md1->body, OP_EQ, test_md1, strlen(test_md1));
+  tt_mem_op(md2->body, OP_EQ, test_md2, strlen(test_md2));
+  tt_mem_op(md3->body, OP_EQ, 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);
-  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_mem_op(md1->body, OP_EQ, s + md1->off, md1->bodylen);
+  tt_mem_op(md2->body, OP_EQ, s + md2->off, md2->bodylen);
+  tt_mem_op(md3->body, OP_EQ, s + md3->off, md3->bodylen);
 
-  tt_ptr_op(md1->family, ==, NULL);
-  tt_ptr_op(md3->family, !=, NULL);
-  tt_int_op(smartlist_len(md3->family), ==, 3);
-  tt_str_op(smartlist_get(md3->family, 0), ==, "nodeX");
+  tt_ptr_op(md1->family, OP_EQ, NULL);
+  tt_ptr_op(md3->family, OP_NE, NULL);
+  tt_int_op(smartlist_len(md3->family), OP_EQ, 3);
+  tt_str_op(smartlist_get(md3->family, 0), OP_EQ, "nodeX");
 
   /* Now rebuild the cache! */
-  tt_int_op(microdesc_cache_rebuild(mc, 1), ==, 0);
+  tt_int_op(microdesc_cache_rebuild(mc, 1), OP_EQ, 0);
 
-  tt_int_op(md1->saved_location, ==, SAVED_IN_CACHE);
-  tt_int_op(md2->saved_location, ==, SAVED_IN_CACHE);
-  tt_int_op(md3->saved_location, ==, SAVED_IN_CACHE);
+  tt_int_op(md1->saved_location, OP_EQ, SAVED_IN_CACHE);
+  tt_int_op(md2->saved_location, OP_EQ, SAVED_IN_CACHE);
+  tt_int_op(md3->saved_location, OP_EQ, SAVED_IN_CACHE);
 
   /* The journal should be empty now */
   tor_free(s);
   s = read_file_to_str(fn, RFTS_BIN, NULL);
-  tt_str_op(s, ==, "");
+  tt_str_op(s, OP_EQ, "");
   tor_free(s);
   tor_free(fn);
 
@@ -185,9 +185,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);
-  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_mem_op(md1->body, OP_EQ, s + md1->off, strlen(test_md1));
+  tt_mem_op(md2->body, OP_EQ, s + md2->off, strlen(test_md2));
+  tt_mem_op(md3->body, OP_EQ, s + md3->off, strlen(test_md3_noannotation));
 
   /* Okay, now we are going to forget about the cache entirely, and reload it
    * from the disk. */
@@ -199,41 +199,41 @@ test_md_cache(void *data)
   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_mem_op(md1->body, OP_EQ, s + md1->off, strlen(test_md1));
+  tt_mem_op(md2->body, OP_EQ, s + md2->off, strlen(test_md2));
+  tt_mem_op(md3->body, OP_EQ, s + md3->off, strlen(test_md3_noannotation));
 
-  tt_int_op(md1->last_listed, ==, time1);
-  tt_int_op(md2->last_listed, ==, time2);
-  tt_int_op(md3->last_listed, ==, time3);
+  tt_int_op(md1->last_listed, OP_EQ, time1);
+  tt_int_op(md2->last_listed, OP_EQ, time2);
+  tt_int_op(md3->last_listed, OP_EQ, time3);
 
   /* Okay, now we are going to clear out everything older than a week old.
    * In practice, that means md3 */
   microdesc_cache_clean(mc, time(NULL)-7*24*60*60, 1/*force*/);
-  tt_ptr_op(md1, ==, microdesc_cache_lookup_by_digest256(mc, d1));
-  tt_ptr_op(md2, ==, microdesc_cache_lookup_by_digest256(mc, d2));
-  tt_ptr_op(NULL, ==, microdesc_cache_lookup_by_digest256(mc, d3));
+  tt_ptr_op(md1, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d1));
+  tt_ptr_op(md2, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d2));
+  tt_ptr_op(NULL, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d3));
   md3 = NULL; /* it's history now! */
 
   /* rebuild again, make sure it stays gone. */
-  tt_int_op(microdesc_cache_rebuild(mc, 1), ==, 0);
-  tt_ptr_op(md1, ==, microdesc_cache_lookup_by_digest256(mc, d1));
-  tt_ptr_op(md2, ==, microdesc_cache_lookup_by_digest256(mc, d2));
-  tt_ptr_op(NULL, ==, microdesc_cache_lookup_by_digest256(mc, d3));
+  tt_int_op(microdesc_cache_rebuild(mc, 1), OP_EQ, 0);
+  tt_ptr_op(md1, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d1));
+  tt_ptr_op(md2, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d2));
+  tt_ptr_op(NULL, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d3));
 
   /* Re-add md3, and make sure we can rebuild the cache. */
   added = microdescs_add_to_cache(mc, test_md3_noannotation, NULL,
                                   SAVED_NOWHERE, 0, time3, NULL);
-  tt_int_op(1, ==, smartlist_len(added));
+  tt_int_op(1, OP_EQ, smartlist_len(added));
   md3 = smartlist_get(added, 0);
   smartlist_free(added);
   added = NULL;
-  tt_int_op(md1->saved_location, ==, SAVED_IN_CACHE);
-  tt_int_op(md2->saved_location, ==, SAVED_IN_CACHE);
-  tt_int_op(md3->saved_location, ==, SAVED_IN_JOURNAL);
+  tt_int_op(md1->saved_location, OP_EQ, SAVED_IN_CACHE);
+  tt_int_op(md2->saved_location, OP_EQ, SAVED_IN_CACHE);
+  tt_int_op(md3->saved_location, OP_EQ, SAVED_IN_JOURNAL);
 
-  tt_int_op(microdesc_cache_rebuild(mc, 1), ==, 0);
-  tt_int_op(md3->saved_location, ==, SAVED_IN_CACHE);
+  tt_int_op(microdesc_cache_rebuild(mc, 1), OP_EQ, 0);
+  tt_int_op(md3->saved_location, OP_EQ, SAVED_IN_CACHE);
 
  done:
   if (options)
@@ -273,9 +273,9 @@ test_md_cache_broken(void *data)
   options->DataDirectory = tor_strdup(get_fname("md_datadir_test2"));
 
 #ifdef _WIN32
-  tt_int_op(0, ==, mkdir(options->DataDirectory));
+  tt_int_op(0, OP_EQ, mkdir(options->DataDirectory));
 #else
-  tt_int_op(0, ==, mkdir(options->DataDirectory, 0700));
+  tt_int_op(0, OP_EQ, mkdir(options->DataDirectory, 0700));
 #endif
 
   tor_asprintf(&fn, "%s"PATH_SEPARATOR"cached-microdescs",
@@ -375,7 +375,7 @@ test_md_generate(void *arg)
   ri = router_parse_entry_from_string(test_ri, NULL, 0, 0, NULL, NULL);
   tt_assert(ri);
   md = dirvote_create_microdescriptor(ri, 8);
-  tt_str_op(md->body, ==, test_md_8);
+  tt_str_op(md->body, OP_EQ, test_md_8);
 
   /* XXXX test family lines. */
   /* XXXX test method 14 for A lines. */
@@ -384,12 +384,12 @@ test_md_generate(void *arg)
   microdesc_free(md);
   md = NULL;
   md = dirvote_create_microdescriptor(ri, 16);
-  tt_str_op(md->body, ==, test_md_16);
+  tt_str_op(md->body, OP_EQ, test_md_16);
 
   microdesc_free(md);
   md = NULL;
   md = dirvote_create_microdescriptor(ri, 18);
-  tt_str_op(md->body, ==, test_md_18);
+  tt_str_op(md->body, OP_EQ, test_md_18);
 
  done:
   microdesc_free(md);
@@ -564,8 +564,8 @@ test_md_parse(void *arg)
   smartlist_t *mds = microdescs_parse_from_string(MD_PARSE_TEST_DATA,
                                                   NULL, 1, SAVED_NOWHERE,
                                                   invalid);
-  tt_int_op(smartlist_len(mds), ==, 11);
-  tt_int_op(smartlist_len(invalid), ==, 4);
+  tt_int_op(smartlist_len(mds), OP_EQ, 11);
+  tt_int_op(smartlist_len(invalid), OP_EQ, 4);
 
   test_memeq_hex(smartlist_get(invalid,0),
                  "5d76bf1c6614e885614a1e0ad074e1ab"
@@ -585,11 +585,11 @@ test_md_parse(void *arg)
   test_memeq_hex(md->digest,
                  "54bb6d733ddeb375d2456c79ae103961"
                  "da0cae29620375ac4cf13d54da4d92b3");
-  tt_int_op(md->last_listed, ==, 0);
-  tt_int_op(md->saved_location, ==, SAVED_NOWHERE);
-  tt_int_op(md->no_save, ==, 0);
-  tt_uint_op(md->held_in_map, ==, 0);
-  tt_uint_op(md->held_by_nodes, ==, 0);
+  tt_int_op(md->last_listed, OP_EQ, 0);
+  tt_int_op(md->saved_location, OP_EQ, SAVED_NOWHERE);
+  tt_int_op(md->no_save, OP_EQ, 0);
+  tt_uint_op(md->held_in_map, OP_EQ, 0);
+  tt_uint_op(md->held_by_nodes, OP_EQ, 0);
   tt_assert(md->onion_curve25519_pkey);
 
   md = smartlist_get(mds, 6);
@@ -609,7 +609,7 @@ test_md_parse(void *arg)
                  "409ebd87d23925a2732bd467a92813c9"
                  "21ca378fcb9ca193d354c51550b6d5e9");
   tt_assert(tor_addr_family(&md->ipv6_addr) == AF_INET6);
-  tt_int_op(md->ipv6_orport, ==, 9090);
+  tt_int_op(md->ipv6_orport, OP_EQ, 9090);
 
  done:
   SMARTLIST_FOREACH(mds, microdesc_t *, md, microdesc_free(md));
@@ -667,9 +667,9 @@ test_md_reject_cache(void *arg)
   mock_ns_val->flavor = FLAV_MICRODESC;
 
 #ifdef _WIN32
-  tt_int_op(0, ==, mkdir(options->DataDirectory));
+  tt_int_op(0, OP_EQ, mkdir(options->DataDirectory));
 #else
-  tt_int_op(0, ==, mkdir(options->DataDirectory, 0700));
+  tt_int_op(0, OP_EQ, mkdir(options->DataDirectory, 0700));
 #endif
 
   MOCK(router_get_mutable_consensus_status_by_descriptor_digest,
@@ -679,7 +679,7 @@ test_md_reject_cache(void *arg)
   mc = get_microdesc_cache();
 #define ADD(hex)                                                        \
   do {                                                                  \
-    tt_int_op(0,==,base16_decode(buf,sizeof(buf),hex,strlen(hex)));     \
+    tt_int_op(0,OP_EQ,base16_decode(buf,sizeof(buf),hex,strlen(hex)));     \
     smartlist_add(wanted, tor_memdup(buf, DIGEST256_LEN));              \
   } while (0)
 
@@ -695,10 +695,10 @@ test_md_reject_cache(void *arg)
   added = microdescs_add_to_cache(mc, MD_PARSE_TEST_DATA, NULL,
                                   SAVED_NOWHERE, 0, time(NULL), wanted);
 
-  tt_int_op(smartlist_len(added), ==, 2);
-  tt_int_op(mock_rgsbd_called, ==, 2);
-  tt_int_op(mock_rgsbd_val_a->dl_status.n_download_failures, ==, 255);
-  tt_int_op(mock_rgsbd_val_b->dl_status.n_download_failures, ==, 255);
+  tt_int_op(smartlist_len(added), OP_EQ, 2);
+  tt_int_op(mock_rgsbd_called, OP_EQ, 2);
+  tt_int_op(mock_rgsbd_val_a->dl_status.n_download_failures, OP_EQ, 255);
+  tt_int_op(mock_rgsbd_val_b->dl_status.n_download_failures, OP_EQ, 255);
 
  done:
   UNMOCK(networkstatus_get_latest_consensus_by_flavor);
diff --git a/src/test/test_nodelist.c b/src/test/test_nodelist.c
index 7c94084..2fba3da 100644
--- a/src/test/test_nodelist.c
+++ b/src/test/test_nodelist.c
@@ -25,7 +25,7 @@ test_nodelist_node_get_verbose_nickname_by_id_null_node(void *arg)
   /* make sure node_get_by_id returns NULL */
   tt_assert(!node_get_by_id(ID));
   node_get_verbose_nickname_by_id(ID, vname);
-  tt_str_op(vname,==, "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
+  tt_str_op(vname,OP_EQ, "$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);
-  tt_str_op(vname,==, "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA~TestOR");
+  tt_str_op(vname,OP_EQ, "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA~TestOR");
 
  done:
   return;
diff --git a/src/test/test_oom.c b/src/test/test_oom.c
index 2726056..1f21f65 100644
--- a/src/test/test_oom.c
+++ b/src/test/test_oom.c
@@ -151,9 +151,9 @@ test_oom_circbuf(void *arg)
   options->MaxMemInQueues = 256*packed_cell_mem_cost();
   options->CellStatistics = 0;
 
-  tt_int_op(cell_queues_check_size(), ==, 0); /* We don't start out OOM. */
-  tt_int_op(cell_queues_get_total_allocation(), ==, 0);
-  tt_int_op(buf_get_total_allocation(), ==, 0);
+  tt_int_op(cell_queues_check_size(), OP_EQ, 0); /* We don't start out OOM. */
+  tt_int_op(cell_queues_get_total_allocation(), OP_EQ, 0);
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 0);
 
   /* Now we're going to fake up some circuits and get them added to the global
      circuit list. */
@@ -165,21 +165,21 @@ test_oom_circbuf(void *arg)
   c2 = dummy_or_circuit_new(20, 20);
 
 #ifdef ENABLE_MEMPOOLS
-  tt_int_op(packed_cell_mem_cost(), ==,
+  tt_int_op(packed_cell_mem_cost(), OP_EQ,
             sizeof(packed_cell_t) + MP_POOL_ITEM_OVERHEAD);
 #else
-  tt_int_op(packed_cell_mem_cost(), ==,
+  tt_int_op(packed_cell_mem_cost(), OP_EQ,
             sizeof(packed_cell_t));
 #endif /* ENABLE_MEMPOOLS */
-  tt_int_op(cell_queues_get_total_allocation(), ==,
+  tt_int_op(cell_queues_get_total_allocation(), OP_EQ,
             packed_cell_mem_cost() * 70);
-  tt_int_op(cell_queues_check_size(), ==, 0); /* We are still not OOM */
+  tt_int_op(cell_queues_check_size(), OP_EQ, 0); /* We are still not OOM */
 
   tv.tv_usec = 20*1000;
   tor_gettimeofday_cache_set(&tv);
   c3 = dummy_or_circuit_new(100, 85);
-  tt_int_op(cell_queues_check_size(), ==, 0); /* We are still not OOM */
-  tt_int_op(cell_queues_get_total_allocation(), ==,
+  tt_int_op(cell_queues_check_size(), OP_EQ, 0); /* We are still not OOM */
+  tt_int_op(cell_queues_get_total_allocation(), OP_EQ,
             packed_cell_mem_cost() * 255);
 
   tv.tv_usec = 30*1000;
@@ -187,17 +187,17 @@ test_oom_circbuf(void *arg)
   /* Adding this cell will trigger our OOM handler. */
   c4 = dummy_or_circuit_new(2, 0);
 
-  tt_int_op(cell_queues_get_total_allocation(), ==,
+  tt_int_op(cell_queues_get_total_allocation(), OP_EQ,
             packed_cell_mem_cost() * 257);
 
-  tt_int_op(cell_queues_check_size(), ==, 1); /* We are now OOM */
+  tt_int_op(cell_queues_check_size(), OP_EQ, 1); /* We are now OOM */
 
   tt_assert(c1->marked_for_close);
   tt_assert(! c2->marked_for_close);
   tt_assert(! c3->marked_for_close);
   tt_assert(! c4->marked_for_close);
 
-  tt_int_op(cell_queues_get_total_allocation(), ==,
+  tt_int_op(cell_queues_get_total_allocation(), OP_EQ,
             packed_cell_mem_cost() * (257 - 30));
 
   circuit_free(c1);
@@ -208,14 +208,14 @@ test_oom_circbuf(void *arg)
   tv.tv_usec = 40*1000; /* go back to the future */
   tor_gettimeofday_cache_set(&tv);
 
-  tt_int_op(cell_queues_check_size(), ==, 1); /* We are now OOM */
+  tt_int_op(cell_queues_check_size(), OP_EQ, 1); /* We are now OOM */
 
   tt_assert(c1->marked_for_close);
   tt_assert(! c2->marked_for_close);
   tt_assert(! c3->marked_for_close);
   tt_assert(! c4->marked_for_close);
 
-  tt_int_op(cell_queues_get_total_allocation(), ==,
+  tt_int_op(cell_queues_get_total_allocation(), OP_EQ,
             packed_cell_mem_cost() * (257 - 30));
 
  done:
@@ -250,9 +250,9 @@ test_oom_streambuf(void *arg)
   options->MaxMemInQueues = 81*packed_cell_mem_cost() + 4096 * 34;
   options->CellStatistics = 0;
 
-  tt_int_op(cell_queues_check_size(), ==, 0); /* We don't start out OOM. */
-  tt_int_op(cell_queues_get_total_allocation(), ==, 0);
-  tt_int_op(buf_get_total_allocation(), ==, 0);
+  tt_int_op(cell_queues_check_size(), OP_EQ, 0); /* We don't start out OOM. */
+  tt_int_op(cell_queues_get_total_allocation(), OP_EQ, 0);
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 0);
 
   /* Start all circuits with a bit of data queued in cells */
   tv.tv_usec = 500*1000; /* go halfway into the second. */
@@ -267,7 +267,7 @@ test_oom_streambuf(void *arg)
   tv.tv_usec = 530*1000;
   tor_gettimeofday_cache_set(&tv);
   c4 = dummy_or_circuit_new(0,0);
-  tt_int_op(cell_queues_get_total_allocation(), ==,
+  tt_int_op(cell_queues_get_total_allocation(), OP_EQ,
             packed_cell_mem_cost() * 80);
 
   tv.tv_usec = 600*1000;
@@ -303,24 +303,24 @@ test_oom_streambuf(void *arg)
   tv.tv_usec = 0;
   tvms = (uint32_t) tv_to_msec(&tv);
 
-  tt_int_op(circuit_max_queued_cell_age(c1, tvms), ==, 500);
-  tt_int_op(circuit_max_queued_cell_age(c2, tvms), ==, 490);
-  tt_int_op(circuit_max_queued_cell_age(c3, tvms), ==, 480);
-  tt_int_op(circuit_max_queued_cell_age(c4, tvms), ==, 0);
+  tt_int_op(circuit_max_queued_cell_age(c1, tvms), OP_EQ, 500);
+  tt_int_op(circuit_max_queued_cell_age(c2, tvms), OP_EQ, 490);
+  tt_int_op(circuit_max_queued_cell_age(c3, tvms), OP_EQ, 480);
+  tt_int_op(circuit_max_queued_cell_age(c4, tvms), OP_EQ, 0);
 
-  tt_int_op(circuit_max_queued_data_age(c1, tvms), ==, 390);
-  tt_int_op(circuit_max_queued_data_age(c2, tvms), ==, 380);
-  tt_int_op(circuit_max_queued_data_age(c3, tvms), ==, 0);
-  tt_int_op(circuit_max_queued_data_age(c4, tvms), ==, 370);
+  tt_int_op(circuit_max_queued_data_age(c1, tvms), OP_EQ, 390);
+  tt_int_op(circuit_max_queued_data_age(c2, tvms), OP_EQ, 380);
+  tt_int_op(circuit_max_queued_data_age(c3, tvms), OP_EQ, 0);
+  tt_int_op(circuit_max_queued_data_age(c4, tvms), OP_EQ, 370);
 
-  tt_int_op(circuit_max_queued_item_age(c1, tvms), ==, 500);
-  tt_int_op(circuit_max_queued_item_age(c2, tvms), ==, 490);
-  tt_int_op(circuit_max_queued_item_age(c3, tvms), ==, 480);
-  tt_int_op(circuit_max_queued_item_age(c4, tvms), ==, 370);
+  tt_int_op(circuit_max_queued_item_age(c1, tvms), OP_EQ, 500);
+  tt_int_op(circuit_max_queued_item_age(c2, tvms), OP_EQ, 490);
+  tt_int_op(circuit_max_queued_item_age(c3, tvms), OP_EQ, 480);
+  tt_int_op(circuit_max_queued_item_age(c4, tvms), OP_EQ, 370);
 
-  tt_int_op(cell_queues_get_total_allocation(), ==,
+  tt_int_op(cell_queues_get_total_allocation(), OP_EQ,
             packed_cell_mem_cost() * 80);
-  tt_int_op(buf_get_total_allocation(), ==, 4096*16*2);
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 4096*16*2);
 
   /* Now give c4 a very old buffer of modest size */
   {
@@ -332,21 +332,21 @@ test_oom_streambuf(void *arg)
     tt_assert(ec);
     smartlist_add(edgeconns, ec);
   }
-  tt_int_op(buf_get_total_allocation(), ==, 4096*17*2);
-  tt_int_op(circuit_max_queued_item_age(c4, tvms), ==, 1000);
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 4096*17*2);
+  tt_int_op(circuit_max_queued_item_age(c4, tvms), OP_EQ, 1000);
 
-  tt_int_op(cell_queues_check_size(), ==, 0);
+  tt_int_op(cell_queues_check_size(), OP_EQ, 0);
 
   /* And run over the limit. */
   tv.tv_usec = 800*1000;
   tor_gettimeofday_cache_set(&tv);
   c5 = dummy_or_circuit_new(0,5);
 
-  tt_int_op(cell_queues_get_total_allocation(), ==,
+  tt_int_op(cell_queues_get_total_allocation(), OP_EQ,
             packed_cell_mem_cost() * 85);
-  tt_int_op(buf_get_total_allocation(), ==, 4096*17*2);
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 4096*17*2);
 
-  tt_int_op(cell_queues_check_size(), ==, 1); /* We are now OOM */
+  tt_int_op(cell_queues_check_size(), OP_EQ, 1); /* We are now OOM */
 
   /* C4 should have died. */
   tt_assert(! c1->marked_for_close);
@@ -355,9 +355,9 @@ test_oom_streambuf(void *arg)
   tt_assert(c4->marked_for_close);
   tt_assert(! c5->marked_for_close);
 
-  tt_int_op(cell_queues_get_total_allocation(), ==,
+  tt_int_op(cell_queues_get_total_allocation(), OP_EQ,
             packed_cell_mem_cost() * 85);
-  tt_int_op(buf_get_total_allocation(), ==, 4096*8*2);
+  tt_int_op(buf_get_total_allocation(), OP_EQ, 4096*8*2);
 
  done:
   circuit_free(c1);
diff --git a/src/test/test_options.c b/src/test/test_options.c
index 57ab38c..44349b3 100644
--- a/src/test/test_options.c
+++ b/src/test/test_options.c
@@ -87,10 +87,10 @@ test_options_validate_impl(const char *configuration,
   clear_log_messages();
 
   r = config_get_lines(configuration, &cl, 1);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
 
   r = config_assign(&options_format, opt, cl, 0, 0, &msg);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
 
   r = options_validate(NULL, opt, dflt, 0, &msg);
   if (expect_errmsg && !msg) {
@@ -103,7 +103,7 @@ test_options_validate_impl(const char *configuration,
     TT_DIE(("Expected no error message from <%s> but got <%s>.",
             configuration, msg));
   }
-  tt_int_op((r == 0), ==, (msg == NULL));
+  tt_int_op((r == 0), OP_EQ, (msg == NULL));
 
   if (expect_log) {
     int found = 0;
diff --git a/src/test/test_policy.c b/src/test/test_policy.c
index c043ac6..e77e16c 100644
--- a/src/test/test_policy.c
+++ b/src/test/test_policy.c
@@ -22,7 +22,7 @@ test_short_policy_parse(const char *input,
   short_policy = parse_short_policy(input);
   tt_assert(short_policy);
   out = write_short_policy(short_policy);
-  tt_str_op(out, ==, expected);
+  tt_str_op(out, OP_EQ, expected);
 
  done:
   tor_free(out);
@@ -50,17 +50,17 @@ test_policy_summary_helper(const char *policy_str,
   r = policies_parse_exit_policy(&line, &policy,
                                  EXIT_POLICY_IPV6_ENABLED |
                                  EXIT_POLICY_ADD_DEFAULT ,0);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 
   summary = policy_summarize(policy, AF_INET);
 
   tt_assert(summary != NULL);
-  tt_str_op(summary,==, expected_summary);
+  tt_str_op(summary,OP_EQ, expected_summary);
 
   short_policy = parse_short_policy(summary);
   tt_assert(short_policy);
   summary_after = write_short_policy(short_policy);
-  tt_str_op(summary,==, summary_after);
+  tt_str_op(summary,OP_EQ, summary_after);
 
  done:
   tor_free(summary_after);
@@ -90,12 +90,12 @@ test_policies_general(void *arg)
 
   p = router_parse_addr_policy_item_from_string("reject 192.168.0.0/16:*",-1);
   tt_assert(p != NULL);
-  tt_int_op(ADDR_POLICY_REJECT,==, p->policy_type);
+  tt_int_op(ADDR_POLICY_REJECT,OP_EQ, p->policy_type);
   tor_addr_from_ipv4h(&tar, 0xc0a80000u);
-  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);
+  tt_int_op(0,OP_EQ, tor_addr_compare(&p->addr, &tar, CMP_EXACT));
+  tt_int_op(16,OP_EQ, p->maskbits);
+  tt_int_op(1,OP_EQ, p->prt_min);
+  tt_int_op(65535,OP_EQ, p->prt_max);
 
   smartlist_add(policy, p);
 
@@ -109,7 +109,7 @@ test_policies_general(void *arg)
   tt_assert(ADDR_POLICY_REJECTED ==
           compare_tor_addr_to_addr_policy(&tar, 2, policy));
 
-  tt_int_op(0, ==, policies_parse_exit_policy(NULL, &policy2,
+  tt_int_op(0, OP_EQ, policies_parse_exit_policy(NULL, &policy2,
                                               EXIT_POLICY_IPV6_ENABLED |
                                               EXIT_POLICY_REJECT_PRIVATE |
                                               EXIT_POLICY_ADD_DEFAULT, 0));
@@ -200,14 +200,14 @@ test_policies_general(void *arg)
   line.key = (char*)"foo";
   line.value = (char*)"accept *:80,reject private:*,reject *:*";
   line.next = NULL;
-  tt_int_op(0, ==, policies_parse_exit_policy(&line,&policy,
+  tt_int_op(0, OP_EQ, policies_parse_exit_policy(&line,&policy,
                                               EXIT_POLICY_IPV6_ENABLED |
                                               EXIT_POLICY_ADD_DEFAULT,0));
   tt_assert(policy);
 
   //test_streq(policy->string, "accept *:80");
   //test_streq(policy->next->string, "reject *:*");
-  tt_int_op(smartlist_len(policy),==, 4);
+  tt_int_op(smartlist_len(policy),OP_EQ, 4);
 
   /* test policy summaries */
   /* check if we properly ignore private IP addresses */
@@ -281,7 +281,7 @@ test_policies_general(void *arg)
   /* Try parsing various broken short policies */
 #define TT_BAD_SHORT_POLICY(s)                                          \
   do {                                                                  \
-    tt_ptr_op(NULL, ==, (short_parsed = parse_short_policy((s))));      \
+    tt_ptr_op(NULL, OP_EQ, (short_parsed = parse_short_policy((s))));      \
   } while (0)
   TT_BAD_SHORT_POLICY("accept 200-199");
   TT_BAD_SHORT_POLICY("");
@@ -311,7 +311,7 @@ test_policies_general(void *arg)
     smartlist_free(chunks);
     short_parsed = parse_short_policy(policy);/* shouldn't be accepted */
     tor_free(policy);
-    tt_ptr_op(NULL, ==, short_parsed);
+    tt_ptr_op(NULL, OP_EQ, short_parsed);
   }
 
   /* truncation ports */
@@ -369,7 +369,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);
 
- tt_str_op("reject *:*",==, ep);
+ tt_str_op("reject *:*",OP_EQ, 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);
 
- tt_str_op("accept *:*",==, ep);
+ tt_str_op("accept *:*",OP_EQ, ep);
 
  tor_free(ep);
 
@@ -392,7 +392,7 @@ test_dump_exit_policy_to_string(void *arg)
 
  ep = router_dump_exit_policy_to_string(ri,1,1);
 
- tt_str_op("accept *:*\nreject *:25",==, ep);
+ tt_str_op("accept *:*\nreject *:25",OP_EQ, ep);
 
  tor_free(ep);
 
@@ -403,7 +403,7 @@ test_dump_exit_policy_to_string(void *arg)
 
  ep = router_dump_exit_policy_to_string(ri,1,1);
 
- tt_str_op("accept *:*\nreject *:25\nreject 8.8.8.8:*",==, ep);
+ tt_str_op("accept *:*\nreject *:25\nreject 8.8.8.8:*",OP_EQ, ep);
  tor_free(ep);
 
  policy_entry =
@@ -414,7 +414,7 @@ test_dump_exit_policy_to_string(void *arg)
  ep = router_dump_exit_policy_to_string(ri,1,1);
 
  tt_str_op("accept *:*\nreject *:25\nreject 8.8.8.8:*\n"
-            "reject6 [fc00::]/7:*",==, ep);
+            "reject6 [fc00::]/7:*",OP_EQ, ep);
  tor_free(ep);
 
  policy_entry =
@@ -425,7 +425,7 @@ test_dump_exit_policy_to_string(void *arg)
  ep = router_dump_exit_policy_to_string(ri,1,1);
 
  tt_str_op("accept *:*\nreject *:25\nreject 8.8.8.8:*\n"
-            "reject6 [fc00::]/7:*\naccept6 [c000::]/3:*",==, ep);
+            "reject6 [fc00::]/7:*\naccept6 [c000::]/3:*",OP_EQ, ep);
 
  done:
 
diff --git a/src/test/test_pt.c b/src/test/test_pt.c
index 1be52ee..dba880e 100644
--- a/src/test/test_pt.c
+++ b/src/test/test_pt.c
@@ -69,7 +69,7 @@ test_pt_parsing(void *arg)
   /* test registered SOCKS version of transport */
   tt_assert(transport->socks_version == PROXY_SOCKS5);
   /* test registered name of transport */
-  tt_str_op(transport->name,==, "trebuchet");
+  tt_str_op(transport->name,OP_EQ, "trebuchet");
 
   reset_mp(mp);
 
@@ -96,7 +96,7 @@ test_pt_parsing(void *arg)
   /* test registered port of transport */
   tt_assert(transport->port == 2999);
   /* test registered name of transport */
-  tt_str_op(transport->name,==, "trebuchy");
+  tt_str_op(transport->name,OP_EQ, "trebuchy");
 
   reset_mp(mp);
 
@@ -105,14 +105,14 @@ test_pt_parsing(void *arg)
           "ARGS:counterweight=3,sling=snappy",
           sizeof(line));
   tt_assert(parse_smethod_line(line, mp) == 0);
-  tt_int_op(1, ==, smartlist_len(mp->transports));
+  tt_int_op(1, OP_EQ, smartlist_len(mp->transports));
   {
     const transport_t *transport = smartlist_get(mp->transports, 0);
     tt_assert(transport);
-    tt_str_op(transport->name, ==, "trebuchet");
-    tt_int_op(transport->port, ==, 9999);
-    tt_str_op(fmt_addr(&transport->addr), ==, "127.0.0.1");
-    tt_str_op(transport->extra_info_args, ==,
+    tt_str_op(transport->name, OP_EQ, "trebuchet");
+    tt_int_op(transport->port, OP_EQ, 9999);
+    tt_str_op(fmt_addr(&transport->addr), OP_EQ, "127.0.0.1");
+    tt_str_op(transport->extra_info_args, OP_EQ,
               "counterweight=3,sling=snappy");
   }
   reset_mp(mp);
@@ -151,9 +151,9 @@ test_pt_get_transport_options(void *arg)
   execve_args[1] = NULL;
 
   mp = managed_proxy_create(transport_list, execve_args, 1);
-  tt_ptr_op(mp, !=, NULL);
+  tt_ptr_op(mp, OP_NE, NULL);
   opt_str = get_transport_options_for_server_proxy(mp);
-  tt_ptr_op(opt_str, ==, NULL);
+  tt_ptr_op(opt_str, OP_EQ, NULL);
 
   smartlist_add(mp->transports_to_launch, tor_strdup("gruyere"));
   smartlist_add(mp->transports_to_launch, tor_strdup("roquefort"));
@@ -176,7 +176,7 @@ test_pt_get_transport_options(void *arg)
   options->ServerTransportOptions = cl;
 
   opt_str = get_transport_options_for_server_proxy(mp);
-  tt_str_op(opt_str, ==,
+  tt_str_op(opt_str, OP_EQ,
             "gruyere:melty=10;gruyere:hardness=se\\;ven;"
             "stnectaire:melty=4;stnectaire:hardness=three");
 
@@ -262,17 +262,17 @@ test_pt_get_extrainfo_string(void *arg)
   mp2 = managed_proxy_create(t2, argv2, 1);
 
   r = parse_smethod_line("SMETHOD hagbard 127.0.0.1:5555", mp1);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   r = parse_smethod_line("SMETHOD celine 127.0.0.1:1723 ARGS:card=no-enemy",
                          mp2);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
 
   /* Force these proxies to look "completed" or they won't generate output. */
   mp1->conf_state = mp2->conf_state = PT_PROTO_COMPLETED;
 
   s = pt_get_extra_info_descriptor_string();
   tt_assert(s);
-  tt_str_op(s, ==,
+  tt_str_op(s, OP_EQ,
             "transport hagbard 127.0.0.1:5555\n"
             "transport celine 127.0.0.1:1723 card=no-enemy\n");
 
@@ -380,7 +380,7 @@ 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 */
-    tt_int_op(retval, ==, 0);
+    tt_int_op(retval, OP_EQ, 0);
     /* check the number of registered transports */
     tt_assert(smartlist_len(mp->transports) == i+1);
     /* check that the mp is still waiting for transports */
@@ -390,23 +390,23 @@ test_pt_configure_proxy(void *arg)
   /* this last configure_proxy() should finalize the proxy configuration. */
   retval = configure_proxy(mp);
   /* retval should be 1 since the proxy finished configuring */
-  tt_int_op(retval, ==, 1);
+  tt_int_op(retval, OP_EQ, 1);
   /* check the mp state */
   tt_assert(mp->conf_state == PT_PROTO_COMPLETED);
 
-  tt_int_op(controlevent_n, ==, 5);
-  tt_int_op(controlevent_event, ==, EVENT_TRANSPORT_LAUNCHED);
-  tt_int_op(smartlist_len(controlevent_msgs), ==, 5);
+  tt_int_op(controlevent_n, OP_EQ, 5);
+  tt_int_op(controlevent_event, OP_EQ, EVENT_TRANSPORT_LAUNCHED);
+  tt_int_op(smartlist_len(controlevent_msgs), OP_EQ, 5);
   smartlist_sort_strings(controlevent_msgs);
-  tt_str_op(smartlist_get(controlevent_msgs, 0), ==,
+  tt_str_op(smartlist_get(controlevent_msgs, 0), OP_EQ,
             "650 TRANSPORT_LAUNCHED server mock1 127.0.0.1 5551\r\n");
-  tt_str_op(smartlist_get(controlevent_msgs, 1), ==,
+  tt_str_op(smartlist_get(controlevent_msgs, 1), OP_EQ,
             "650 TRANSPORT_LAUNCHED server mock2 127.0.0.1 5552\r\n");
-  tt_str_op(smartlist_get(controlevent_msgs, 2), ==,
+  tt_str_op(smartlist_get(controlevent_msgs, 2), OP_EQ,
             "650 TRANSPORT_LAUNCHED server mock3 127.0.0.1 5553\r\n");
-  tt_str_op(smartlist_get(controlevent_msgs, 3), ==,
+  tt_str_op(smartlist_get(controlevent_msgs, 3), OP_EQ,
             "650 TRANSPORT_LAUNCHED server mock4 127.0.0.1 5554\r\n");
-  tt_str_op(smartlist_get(controlevent_msgs, 4), ==,
+  tt_str_op(smartlist_get(controlevent_msgs, 4), OP_EQ,
             "650 TRANSPORT_LAUNCHED server mock5 127.0.0.1 5555\r\n");
 
   { /* check that the transport info were saved properly in the tor state */
@@ -423,8 +423,8 @@ test_pt_configure_proxy(void *arg)
                            NULL, 0, 0);
     name_of_transport = smartlist_get(transport_info_sl, 0);
     bindaddr = smartlist_get(transport_info_sl, 1);
-    tt_str_op(name_of_transport, ==, "mock1");
-    tt_str_op(bindaddr, ==, "127.0.0.1:5551");
+    tt_str_op(name_of_transport, OP_EQ, "mock1");
+    tt_str_op(bindaddr, OP_EQ, "127.0.0.1:5551");
 
     SMARTLIST_FOREACH(transport_info_sl, char *, cp, tor_free(cp));
     smartlist_free(transport_info_sl);
@@ -470,9 +470,9 @@ test_get_pt_proxy_uri(void *arg)
   ret = tor_addr_port_lookup(options->Socks4Proxy,
                              &options->Socks4ProxyAddr,
                              &options->Socks4ProxyPort);
-  tt_int_op(ret, ==, 0);
+  tt_int_op(ret, OP_EQ, 0);
   uri = get_pt_proxy_uri();
-  tt_str_op(uri, ==, "socks4a://192.0.2.1:1080");
+  tt_str_op(uri, OP_EQ, "socks4a://192.0.2.1:1080");
   tor_free(uri);
   tor_free(options->Socks4Proxy);
 
@@ -481,16 +481,16 @@ test_get_pt_proxy_uri(void *arg)
   ret = tor_addr_port_lookup(options->Socks5Proxy,
                              &options->Socks5ProxyAddr,
                              &options->Socks5ProxyPort);
-  tt_int_op(ret, ==, 0);
+  tt_int_op(ret, OP_EQ, 0);
   uri = get_pt_proxy_uri();
-  tt_str_op(uri, ==, "socks5://192.0.2.1:1080");
+  tt_str_op(uri, OP_EQ, "socks5://192.0.2.1:1080");
   tor_free(uri);
 
   /* Test with a SOCKS5 proxy, with username/password. */
   options->Socks5ProxyUsername = tor_strdup("hwest");
   options->Socks5ProxyPassword = tor_strdup("r34n1m470r");
   uri = get_pt_proxy_uri();
-  tt_str_op(uri, ==, "socks5://hwest:r34n1m470r@xxxxxxxxx:1080");
+  tt_str_op(uri, OP_EQ, "socks5://hwest:r34n1m470r@xxxxxxxxx:1080");
   tor_free(uri);
   tor_free(options->Socks5Proxy);
   tor_free(options->Socks5ProxyUsername);
@@ -501,15 +501,15 @@ test_get_pt_proxy_uri(void *arg)
   ret = tor_addr_port_lookup(options->HTTPSProxy,
                              &options->HTTPSProxyAddr,
                              &options->HTTPSProxyPort);
-  tt_int_op(ret, ==, 0);
+  tt_int_op(ret, OP_EQ, 0);
   uri = get_pt_proxy_uri();
-  tt_str_op(uri, ==, "http://192.0.2.1:80";);
+  tt_str_op(uri, OP_EQ, "http://192.0.2.1:80";);
   tor_free(uri);
 
   /* Test with a HTTPS proxy, with authenticator. */
   options->HTTPSProxyAuthenticator = tor_strdup("hwest:r34n1m470r");
   uri = get_pt_proxy_uri();
-  tt_str_op(uri, ==, "http://hwest:r34n1m470r@xxxxxxxxx:80";);
+  tt_str_op(uri, OP_EQ, "http://hwest:r34n1m470r@xxxxxxxxx:80";);
   tor_free(uri);
   tor_free(options->HTTPSProxy);
   tor_free(options->HTTPSProxyAuthenticator);
@@ -519,9 +519,9 @@ test_get_pt_proxy_uri(void *arg)
   ret = tor_addr_port_lookup(options->Socks4Proxy,
                              &options->Socks4ProxyAddr,
                              &options->Socks4ProxyPort);
-  tt_int_op(ret, ==, 0);
+  tt_int_op(ret, OP_EQ, 0);
   uri = get_pt_proxy_uri();
-  tt_str_op(uri, ==, "socks4a://[2001:db8::1]:1080");
+  tt_str_op(uri, OP_EQ, "socks4a://[2001:db8::1]:1080");
   tor_free(uri);
   tor_free(options->Socks4Proxy);
 
diff --git a/src/test/test_relaycell.c b/src/test/test_relaycell.c
index 5deb362..834dfef 100644
--- a/src/test/test_relaycell.c
+++ b/src/test/test_relaycell.c
@@ -87,24 +87,24 @@ test_relaycell_resolved(void *arg)
     srm_ncalls = mum_ncalls = 0;                \
   } while (0)
 #define ASSERT_MARK_CALLED(reason) do {         \
-    tt_int_op(mum_ncalls, ==, 1);               \
-    tt_ptr_op(mum_conn, ==, entryconn);         \
-    tt_int_op(mum_endreason, ==, (reason));     \
+    tt_int_op(mum_ncalls, OP_EQ, 1);               \
+    tt_ptr_op(mum_conn, OP_EQ, entryconn);         \
+    tt_int_op(mum_endreason, OP_EQ, (reason));     \
   } while (0)
 #define ASSERT_RESOLVED_CALLED(atype, answer, ttl, expires) do {  \
-    tt_int_op(srm_ncalls, ==, 1);                                 \
-    tt_ptr_op(srm_conn, ==, entryconn);                           \
-    tt_int_op(srm_atype, ==, (atype));                            \
+    tt_int_op(srm_ncalls, OP_EQ, 1);                                 \
+    tt_ptr_op(srm_conn, OP_EQ, entryconn);                           \
+    tt_int_op(srm_atype, OP_EQ, (atype));                            \
     if (answer) {                                                 \
-      tt_int_op(srm_alen, ==, sizeof(answer)-1);                  \
-      tt_int_op(srm_alen, <, 512);                                \
-      tt_int_op(srm_answer_is_set, ==, 1);                        \
-      tt_mem_op(srm_answer, ==, answer, sizeof(answer)-1);        \
+      tt_int_op(srm_alen, OP_EQ, sizeof(answer)-1);                  \
+      tt_int_op(srm_alen, OP_LT, 512);                                \
+      tt_int_op(srm_answer_is_set, OP_EQ, 1);                        \
+      tt_mem_op(srm_answer, OP_EQ, answer, sizeof(answer)-1);        \
     } else {                                                      \
-      tt_int_op(srm_answer_is_set, ==, 0);                        \
+      tt_int_op(srm_answer_is_set, OP_EQ, 0);                        \
     }                                                             \
-    tt_int_op(srm_ttl, ==, ttl);                                  \
-    tt_int_op(srm_expires, ==, expires);                          \
+    tt_int_op(srm_ttl, OP_EQ, ttl);                                  \
+    tt_int_op(srm_expires, OP_EQ, expires);                          \
   } while (0)
 
   (void)arg;
@@ -130,9 +130,9 @@ test_relaycell_resolved(void *arg)
   /* Try with connection in non-RESOLVE_WAIT state: cell gets ignored */
   MOCK_RESET();
   r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
-  tt_int_op(r, ==, 0);
-  tt_int_op(srm_ncalls, ==, 0);
-  tt_int_op(mum_ncalls, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(srm_ncalls, OP_EQ, 0);
+  tt_int_op(mum_ncalls, OP_EQ, 0);
 
   /* Now put it in the right state. */
   ENTRY_TO_CONN(entryconn)->state = AP_CONN_STATE_RESOLVE_WAIT;
@@ -144,7 +144,7 @@ test_relaycell_resolved(void *arg)
   /* We prefer ipv4, so we should get the first ipv4 answer */
   MOCK_RESET();
   r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   ASSERT_MARK_CALLED(END_STREAM_REASON_DONE|
                      END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
   ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_IPV4, "\x7f\x00\x01\x02", 256, -1);
@@ -153,7 +153,7 @@ test_relaycell_resolved(void *arg)
   MOCK_RESET();
   options->ClientDNSRejectInternalAddresses = 1;
   r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   ASSERT_MARK_CALLED(END_STREAM_REASON_DONE|
                      END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
   ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_IPV4, "\x12\x00\x00\x01", 512, -1);
@@ -162,7 +162,7 @@ test_relaycell_resolved(void *arg)
   entryconn->prefer_ipv6_traffic = 1;
   MOCK_RESET();
   r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   ASSERT_MARK_CALLED(END_STREAM_REASON_DONE|
                      END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
   ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_IPV6,
@@ -174,7 +174,7 @@ test_relaycell_resolved(void *arg)
   MOCK_RESET();
   SET_CELL("\x04\x04\x12\x00\x00\x01\x00\x00\x02\x00");
   r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   ASSERT_MARK_CALLED(END_STREAM_REASON_DONE|
                      END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
   ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_IPV4, "\x12\x00\x00\x01", 512, -1);
@@ -184,7 +184,7 @@ test_relaycell_resolved(void *arg)
   MOCK_RESET();
   entryconn->ipv4_traffic_ok = 0;
   r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   ASSERT_MARK_CALLED(END_STREAM_REASON_DONE|
                      END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
   ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_ERROR, NULL, -1, -1);
@@ -194,7 +194,7 @@ test_relaycell_resolved(void *arg)
   entryconn->ipv4_traffic_ok = 1;
   entryconn->socks_request->command = SOCKS_COMMAND_RESOLVE_PTR;
   r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   ASSERT_MARK_CALLED(END_STREAM_REASON_DONE|
                      END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
   ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_ERROR, NULL, -1, -1);
@@ -203,7 +203,7 @@ test_relaycell_resolved(void *arg)
   MOCK_RESET();
   SET_CELL("\x00\x0fwww.example.com\x00\x01\x00\x00");
   r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   ASSERT_MARK_CALLED(END_STREAM_REASON_DONE|
                      END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
   ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_HOSTNAME, "www.example.com", 65536, -1);
@@ -213,9 +213,9 @@ test_relaycell_resolved(void *arg)
   entryconn->socks_request->command = SOCKS_COMMAND_RESOLVE;
   SET_CELL("\x04\x04\x01\x02\x03\x04"); /* no ttl */
   r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   ASSERT_MARK_CALLED(END_STREAM_REASON_TORPROTOCOL);
-  tt_int_op(srm_ncalls, ==, 0);
+  tt_int_op(srm_ncalls, OP_EQ, 0);
 
   /* error on all addresses private */
   MOCK_RESET();
@@ -224,7 +224,7 @@ test_relaycell_resolved(void *arg)
            /* IPv4: 192.168.1.1, ttl 256 */
            "\x04\x04\xc0\xa8\x01\x01\x00\x00\x01\x00");
   r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   ASSERT_MARK_CALLED(END_STREAM_REASON_TORPROTOCOL);
   ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_ERROR_TRANSIENT, NULL, 0, TIME_MAX);
 
@@ -232,7 +232,7 @@ test_relaycell_resolved(void *arg)
   MOCK_RESET();
   SET_CELL("\xf0\x15" "quiet and meaningless" "\x00\x00\x0f\xff");
   r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   ASSERT_MARK_CALLED(END_STREAM_REASON_DONE|
                      END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
   ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_ERROR_TRANSIENT, NULL, -1, -1);
diff --git a/src/test/test_replay.c b/src/test/test_replay.c
index bb8017d..b1f637a 100644
--- a/src/test/test_replay.c
+++ b/src/test/test_replay.c
@@ -44,7 +44,7 @@ test_replaycache_badalloc(void *arg)
   /* Negative interval should get adjusted to zero */
   r = replaycache_new(600, -300);
   tt_assert(r != NULL);
-  tt_int_op(r->scrub_interval,==, 0);
+  tt_int_op(r->scrub_interval,OP_EQ, 0);
   replaycache_free(r);
   /* Negative horizon and negative interval should still fail */
   r = replaycache_new(-600, -300);
@@ -81,13 +81,13 @@ test_replaycache_miss(void *arg)
   result =
     replaycache_add_and_test_internal(1200, r, test_buffer,
         strlen(test_buffer), NULL);
-  tt_int_op(result,==, 0);
+  tt_int_op(result,OP_EQ, 0);
 
   /* poke the bad-parameter error case too */
   result =
     replaycache_add_and_test_internal(1200, NULL, test_buffer,
         strlen(test_buffer), NULL);
-  tt_int_op(result,==, 0);
+  tt_int_op(result,OP_EQ, 0);
 
  done:
   if (r) replaycache_free(r);
@@ -108,12 +108,12 @@ test_replaycache_hit(void *arg)
   result =
     replaycache_add_and_test_internal(1200, r, test_buffer,
         strlen(test_buffer), NULL);
-  tt_int_op(result,==, 0);
+  tt_int_op(result,OP_EQ, 0);
 
   result =
     replaycache_add_and_test_internal(1300, r, test_buffer,
         strlen(test_buffer), NULL);
-  tt_int_op(result,==, 1);
+  tt_int_op(result,OP_EQ, 1);
 
  done:
   if (r) replaycache_free(r);
@@ -134,17 +134,17 @@ test_replaycache_age(void *arg)
   result =
     replaycache_add_and_test_internal(1200, r, test_buffer,
         strlen(test_buffer), NULL);
-  tt_int_op(result,==, 0);
+  tt_int_op(result,OP_EQ, 0);
 
   result =
     replaycache_add_and_test_internal(1300, r, test_buffer,
         strlen(test_buffer), NULL);
-  tt_int_op(result,==, 1);
+  tt_int_op(result,OP_EQ, 1);
 
   result =
     replaycache_add_and_test_internal(3000, r, test_buffer,
         strlen(test_buffer), NULL);
-  tt_int_op(result,==, 0);
+  tt_int_op(result,OP_EQ, 0);
 
  done:
   if (r) replaycache_free(r);
@@ -166,13 +166,13 @@ test_replaycache_elapsed(void *arg)
   result =
     replaycache_add_and_test_internal(1200, r, test_buffer,
         strlen(test_buffer), NULL);
-  tt_int_op(result,==, 0);
+  tt_int_op(result,OP_EQ, 0);
 
   result =
     replaycache_add_and_test_internal(1300, r, test_buffer,
         strlen(test_buffer), &elapsed);
-  tt_int_op(result,==, 1);
-  tt_int_op(elapsed,==, 100);
+  tt_int_op(result,OP_EQ, 1);
+  tt_int_op(elapsed,OP_EQ, 100);
 
  done:
   if (r) replaycache_free(r);
@@ -193,17 +193,17 @@ test_replaycache_noexpire(void *arg)
   result =
     replaycache_add_and_test_internal(1200, r, test_buffer,
         strlen(test_buffer), NULL);
-  tt_int_op(result,==, 0);
+  tt_int_op(result,OP_EQ, 0);
 
   result =
     replaycache_add_and_test_internal(1300, r, test_buffer,
         strlen(test_buffer), NULL);
-  tt_int_op(result,==, 1);
+  tt_int_op(result,OP_EQ, 1);
 
   result =
     replaycache_add_and_test_internal(3000, r, test_buffer,
         strlen(test_buffer), NULL);
-  tt_int_op(result,==, 1);
+  tt_int_op(result,OP_EQ, 1);
 
  done:
   if (r) replaycache_free(r);
@@ -225,12 +225,12 @@ test_replaycache_scrub(void *arg)
   result =
     replaycache_add_and_test_internal(100, r, test_buffer,
         strlen(test_buffer), NULL);
-  tt_int_op(result,==, 0);
+  tt_int_op(result,OP_EQ, 0);
 
   result =
     replaycache_add_and_test_internal(200, r, test_buffer,
         strlen(test_buffer), NULL);
-  tt_int_op(result,==, 1);
+  tt_int_op(result,OP_EQ, 1);
 
   /*
    * Poke a few replaycache_scrub_if_needed_internal() error cases that
@@ -245,7 +245,7 @@ test_replaycache_scrub(void *arg)
   /* Make sure we hit the aging-out case too */
   replaycache_scrub_if_needed_internal(1500, r);
   /* Assert that we aged it */
-  tt_int_op(digestmap_size(r->digests_seen),==, 0);
+  tt_int_op(digestmap_size(r->digests_seen),OP_EQ, 0);
 
  done:
   if (r) replaycache_free(r);
@@ -268,16 +268,16 @@ test_replaycache_future(void *arg)
   result =
     replaycache_add_and_test_internal(100, r, test_buffer,
         strlen(test_buffer), &elapsed);
-  tt_int_op(result,==, 0);
+  tt_int_op(result,OP_EQ, 0);
   /* elapsed should still be 0, since it wasn't written */
-  tt_int_op(elapsed,==, 0);
+  tt_int_op(elapsed,OP_EQ, 0);
 
   result =
     replaycache_add_and_test_internal(200, r, test_buffer,
         strlen(test_buffer), &elapsed);
-  tt_int_op(result,==, 1);
+  tt_int_op(result,OP_EQ, 1);
   /* elapsed should be the time since the last hit */
-  tt_int_op(elapsed,==, 100);
+  tt_int_op(elapsed,OP_EQ, 100);
 
   /*
    * Now let's turn the clock back to get coverage on the cache entry from the
@@ -287,9 +287,9 @@ test_replaycache_future(void *arg)
     replaycache_add_and_test_internal(150, r, test_buffer,
         strlen(test_buffer), &elapsed);
   /* We should still get a hit */
-  tt_int_op(result,==, 1);
+  tt_int_op(result,OP_EQ, 1);
   /* ...but it shouldn't let us see a negative elapsed time */
-  tt_int_op(elapsed,==, 0);
+  tt_int_op(elapsed,OP_EQ, 0);
 
  done:
   if (r) replaycache_free(r);
@@ -316,18 +316,18 @@ test_replaycache_realtime(void *arg)
   /* This should miss */
   result =
     replaycache_add_and_test(r, test_buffer, strlen(test_buffer));
-  tt_int_op(result,==, 0);
+  tt_int_op(result,OP_EQ, 0);
 
   /* This should hit */
   result =
     replaycache_add_and_test(r, test_buffer, strlen(test_buffer));
-  tt_int_op(result,==, 1);
+  tt_int_op(result,OP_EQ, 1);
 
   /* This should hit and return a small elapsed time */
   result =
     replaycache_add_test_and_elapsed(r, test_buffer,
                                      strlen(test_buffer), &elapsed);
-  tt_int_op(result,==, 1);
+  tt_int_op(result,OP_EQ, 1);
   tt_assert(elapsed >= 0);
   tt_assert(elapsed <= 5);
 
diff --git a/src/test/test_routerkeys.c b/src/test/test_routerkeys.c
index 652d7d6..d8ad59a 100644
--- a/src/test/test_routerkeys.c
+++ b/src/test/test_routerkeys.c
@@ -33,38 +33,38 @@ test_routerkeys_write_fingerprint(void *arg)
   set_server_identity_key(key);
   set_client_identity_key(crypto_pk_dup_key(key));
 
-  tt_int_op(0, ==, check_private_dir(ddir, CPD_CREATE, NULL));
-  tt_int_op(crypto_pk_cmp_keys(get_server_identity_key(),key),==,0);
+  tt_int_op(0, OP_EQ, check_private_dir(ddir, CPD_CREATE, NULL));
+  tt_int_op(crypto_pk_cmp_keys(get_server_identity_key(),key),OP_EQ,0);
 
   /* Write fingerprint file */
-  tt_int_op(0, ==, router_write_fingerprint(0));
+  tt_int_op(0, OP_EQ, router_write_fingerprint(0));
   cp = read_file_to_str(get_fname("write_fingerprint/fingerprint"),
                         0, NULL);
   crypto_pk_get_fingerprint(key, fp, 0);
   tor_asprintf(&cp2, "haflinger %s\n", fp);
-  tt_str_op(cp, ==, cp2);
+  tt_str_op(cp, OP_EQ, cp2);
   tor_free(cp);
   tor_free(cp2);
 
   /* Write hashed-fingerprint file */
-  tt_int_op(0, ==, router_write_fingerprint(1));
+  tt_int_op(0, OP_EQ, router_write_fingerprint(1));
   cp = read_file_to_str(get_fname("write_fingerprint/hashed-fingerprint"),
                         0, NULL);
   crypto_pk_get_hashed_fingerprint(key, fp);
   tor_asprintf(&cp2, "haflinger %s\n", fp);
-  tt_str_op(cp, ==, cp2);
+  tt_str_op(cp, OP_EQ, cp2);
   tor_free(cp);
   tor_free(cp2);
 
   /* Replace outdated file */
   write_str_to_file(get_fname("write_fingerprint/hashed-fingerprint"),
                     "junk goes here", 0);
-  tt_int_op(0, ==, router_write_fingerprint(1));
+  tt_int_op(0, OP_EQ, router_write_fingerprint(1));
   cp = read_file_to_str(get_fname("write_fingerprint/hashed-fingerprint"),
                         0, NULL);
   crypto_pk_get_hashed_fingerprint(key, fp);
   tor_asprintf(&cp2, "haflinger %s\n", fp);
-  tt_str_op(cp, ==, cp2);
+  tt_str_op(cp, OP_EQ, cp2);
   tor_free(cp);
   tor_free(cp2);
 
diff --git a/src/test/test_routerset.c b/src/test/test_routerset.c
index 81e4dbb..9bd0c12 100644
--- a/src/test/test_routerset.c
+++ b/src/test/test_routerset.c
@@ -25,12 +25,12 @@ NS(test_main)(void *arg)
 
   rs = routerset_new();
 
-  tt_ptr_op(rs, !=, NULL);
-  tt_ptr_op(rs->list, !=, NULL);
-  tt_ptr_op(rs->names, !=, NULL);
-  tt_ptr_op(rs->digests, !=, NULL);
-  tt_ptr_op(rs->policies, !=, NULL);
-  tt_ptr_op(rs->country_names, !=, NULL);
+  tt_ptr_op(rs, OP_NE, NULL);
+  tt_ptr_op(rs->list, OP_NE, NULL);
+  tt_ptr_op(rs->names, OP_NE, NULL);
+  tt_ptr_op(rs->digests, OP_NE, NULL);
+  tt_ptr_op(rs->policies, OP_NE, NULL);
+  tt_ptr_op(rs->country_names, OP_NE, NULL);
 
   done:
     routerset_free(rs);
@@ -53,30 +53,30 @@ NS(test_main)(void *arg)
   /* strlen(c) < 4 */
   input = "xxx";
   name = routerset_get_countryname(input);
-  tt_ptr_op(name, ==, NULL);
+  tt_ptr_op(name, OP_EQ, NULL);
   tor_free(name);
 
   /* c[0] != '{' */
   input = "xxx}";
   name = routerset_get_countryname(input);
-  tt_ptr_op(name, ==, NULL);
+  tt_ptr_op(name, OP_EQ, NULL);
   tor_free(name);
 
   /* c[3] != '}' */
   input = "{xxx";
   name = routerset_get_countryname(input);
-  tt_ptr_op(name, ==, NULL);
+  tt_ptr_op(name, OP_EQ, NULL);
   tor_free(name);
 
   /* tor_strlower */
   input = "{XX}";
   name = routerset_get_countryname(input);
-  tt_str_op(name, ==, "xx");
+  tt_str_op(name, OP_EQ, "xx");
   tor_free(name);
 
   input = "{xx}";
   name = routerset_get_countryname(input);
-  tt_str_op(name, ==, "xx");
+  tt_str_op(name, OP_EQ, "xx");
   done:
     tor_free(name);
 }
@@ -103,10 +103,10 @@ NS(test_main)(void *arg)
 
   routerset_refresh_countries(set);
 
-  tt_ptr_op(set->countries, ==, NULL);
-  tt_int_op(set->n_countries, ==, 0);
-  tt_int_op(CALLED(geoip_is_loaded), ==, 1);
-  tt_int_op(CALLED(geoip_get_n_countries), ==, 0);
+  tt_ptr_op(set->countries, OP_EQ, NULL);
+  tt_int_op(set->n_countries, OP_EQ, 0);
+  tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1);
+  tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 0);
 
   done:
     NS_UNMOCK(geoip_is_loaded);
@@ -154,12 +154,12 @@ NS(test_main)(void *arg)
 
   routerset_refresh_countries(set);
 
-  tt_ptr_op(set->countries, !=, NULL);
-  tt_int_op(set->n_countries, ==, 1);
-  tt_int_op((unsigned int)(*set->countries), ==, 0);
-  tt_int_op(CALLED(geoip_is_loaded), ==, 1);
-  tt_int_op(CALLED(geoip_get_n_countries), ==, 1);
-  tt_int_op(CALLED(geoip_get_country), ==, 0);
+  tt_ptr_op(set->countries, OP_NE, NULL);
+  tt_int_op(set->n_countries, OP_EQ, 1);
+  tt_int_op((unsigned int)(*set->countries), OP_EQ, 0);
+  tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1);
+  tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 1);
+  tt_int_op(CALLED(geoip_get_country), OP_EQ, 0);
 
   done:
     NS_UNMOCK(geoip_is_loaded);
@@ -218,12 +218,12 @@ NS(test_main)(void *arg)
 
   routerset_refresh_countries(set);
 
-  tt_ptr_op(set->countries, !=, NULL);
-  tt_int_op(set->n_countries, ==, 2);
-  tt_int_op(CALLED(geoip_is_loaded), ==, 1);
-  tt_int_op(CALLED(geoip_get_n_countries), ==, 1);
-  tt_int_op(CALLED(geoip_get_country), ==, 1);
-  tt_int_op((unsigned int)(*set->countries), !=, 0);
+  tt_ptr_op(set->countries, OP_NE, NULL);
+  tt_int_op(set->n_countries, OP_EQ, 2);
+  tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1);
+  tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 1);
+  tt_int_op(CALLED(geoip_get_country), OP_EQ, 1);
+  tt_int_op((unsigned int)(*set->countries), OP_NE, 0);
 
   done:
     NS_UNMOCK(geoip_is_loaded);
@@ -283,12 +283,12 @@ NS(test_main)(void *arg)
 
   routerset_refresh_countries(set);
 
-  tt_ptr_op(set->countries, !=, NULL);
-  tt_int_op(set->n_countries, ==, 2);
-  tt_int_op(CALLED(geoip_is_loaded), ==, 1);
-  tt_int_op(CALLED(geoip_get_n_countries), ==, 1);
-  tt_int_op(CALLED(geoip_get_country), ==, 1);
-  tt_int_op((unsigned int)(*set->countries), ==, 0);
+  tt_ptr_op(set->countries, OP_NE, NULL);
+  tt_int_op(set->n_countries, OP_EQ, 2);
+  tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1);
+  tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 1);
+  tt_int_op(CALLED(geoip_get_country), OP_EQ, 1);
+  tt_int_op((unsigned int)(*set->countries), OP_EQ, 0);
 
   done:
     NS_UNMOCK(geoip_is_loaded);
@@ -340,7 +340,7 @@ NS(test_main)(void *arg)
 
   r = routerset_parse(set, s, "");
 
-  tt_int_op(r, ==, -1);
+  tt_int_op(r, OP_EQ, -1);
 
   done:
     routerset_free(set);
@@ -365,8 +365,8 @@ NS(test_main)(void *arg)
   set = routerset_new();
   s = "$0000000000000000000000000000000000000000";
   r = routerset_parse(set, s, "");
-  tt_int_op(r, ==, 0);
-  tt_int_op(digestmap_isempty(set->digests), !=, 1);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(digestmap_isempty(set->digests), OP_NE, 1);
 
   done:
     routerset_free(set);
@@ -390,8 +390,8 @@ NS(test_main)(void *arg)
   set = routerset_new();
   s = "fred";
   r = routerset_parse(set, s, "");
-  tt_int_op(r, ==, 0);
-  tt_int_op(strmap_isempty(set->names), !=, 1);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(strmap_isempty(set->names), OP_NE, 1);
 
   done:
     routerset_free(set);
@@ -415,8 +415,8 @@ NS(test_main)(void *arg)
   set = routerset_new();
   s = "{cc}";
   r = routerset_parse(set, s, "");
-  tt_int_op(r, ==, 0);
-  tt_int_op(smartlist_len(set->country_names), !=, 0);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(smartlist_len(set->country_names), OP_NE, 0);
 
   done:
     routerset_free(set);
@@ -448,9 +448,9 @@ NS(test_main)(void *arg)
   set = routerset_new();
   s = "*";
   r = routerset_parse(set, s, "");
-  tt_int_op(r, ==, 0);
-  tt_int_op(smartlist_len(set->policies), !=, 0);
-  tt_int_op(CALLED(router_parse_addr_policy_item_from_string), ==, 1);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(smartlist_len(set->policies), OP_NE, 0);
+  tt_int_op(CALLED(router_parse_addr_policy_item_from_string), OP_EQ, 1);
 
   done:
     routerset_free(set);
@@ -489,10 +489,10 @@ NS(test_main)(void *arg)
   NS_MOCK(smartlist_new);
 
   routerset_union(set, NULL);
-  tt_int_op(CALLED(smartlist_new), ==, 0);
+  tt_int_op(CALLED(smartlist_new), OP_EQ, 0);
 
   routerset_union(set, bad_set);
-  tt_int_op(CALLED(smartlist_new), ==, 0);
+  tt_int_op(CALLED(smartlist_new), OP_EQ, 0);
 
   done:
     NS_UNMOCK(smartlist_new);
@@ -529,7 +529,7 @@ NS(test_main)(void *arg)
   smartlist_add(src->list, tor_strdup("{xx}"));
   routerset_union(tgt, src);
 
-  tt_int_op(smartlist_len(tgt->list), !=, 0);
+  tt_int_op(smartlist_len(tgt->list), OP_NE, 0);
 
   done:
     routerset_free(src);
@@ -556,7 +556,7 @@ NS(test_main)(void *arg)
   is_list = routerset_is_list(set);
   routerset_free(set);
   set = NULL;
-  tt_int_op(is_list, !=, 0);
+  tt_int_op(is_list, OP_NE, 0);
 
   /* len(set->country_names) != 0, len(set->policies) == 0 */
   set = routerset_new();
@@ -564,7 +564,7 @@ NS(test_main)(void *arg)
   is_list = routerset_is_list(set);
   routerset_free(set);
   set = NULL;
-  tt_int_op(is_list, ==, 0);
+  tt_int_op(is_list, OP_EQ, 0);
 
   /* len(set->country_names) == 0, len(set->policies) != 0 */
   set = routerset_new();
@@ -573,7 +573,7 @@ NS(test_main)(void *arg)
   is_list = routerset_is_list(set);
   routerset_free(set);
   set = NULL;
-  tt_int_op(is_list, ==, 0);
+  tt_int_op(is_list, OP_EQ, 0);
 
   /* len(set->country_names) != 0, len(set->policies) != 0 */
   set = routerset_new();
@@ -583,7 +583,7 @@ NS(test_main)(void *arg)
   is_list = routerset_is_list(set);
   routerset_free(set);
   set = NULL;
-  tt_int_op(is_list, ==, 0);
+  tt_int_op(is_list, OP_EQ, 0);
 
   done:
     ;
@@ -605,12 +605,12 @@ NS(test_main)(void *arg)
 
   set = NULL;
   needs_geoip = routerset_needs_geoip(set);
-  tt_int_op(needs_geoip, ==, 0);
+  tt_int_op(needs_geoip, OP_EQ, 0);
 
   set = routerset_new();
   needs_geoip = routerset_needs_geoip(set);
   routerset_free((routerset_t *)set);
-  tt_int_op(needs_geoip, ==, 0);
+  tt_int_op(needs_geoip, OP_EQ, 0);
   set = NULL;
 
   set = routerset_new();
@@ -618,7 +618,7 @@ NS(test_main)(void *arg)
   needs_geoip = routerset_needs_geoip(set);
   routerset_free((routerset_t *)set);
   set = NULL;
-  tt_int_op(needs_geoip, !=, 0);
+  tt_int_op(needs_geoip, OP_NE, 0);
 
   done:
     ;
@@ -639,20 +639,20 @@ NS(test_main)(void *arg)
   (void)arg;
 
   is_empty = routerset_is_empty(set);
-  tt_int_op(is_empty, !=, 0);
+  tt_int_op(is_empty, OP_NE, 0);
 
   set = routerset_new();
   is_empty = routerset_is_empty(set);
   routerset_free(set);
   set = NULL;
-  tt_int_op(is_empty, !=, 0);
+  tt_int_op(is_empty, OP_NE, 0);
 
   set = routerset_new();
   smartlist_add(set->list, tor_strdup("{xx}"));
   is_empty = routerset_is_empty(set);
   routerset_free(set);
   set = NULL;
-  tt_int_op(is_empty, ==, 0);
+  tt_int_op(is_empty, OP_EQ, 0);
 
   done:
     ;
@@ -675,13 +675,13 @@ NS(test_main)(void *arg)
 
   contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
 
-  tt_int_op(contains, ==, 0);
+  tt_int_op(contains, OP_EQ, 0);
 
   set = tor_malloc_zero(sizeof(routerset_t));
   set->list = NULL;
   contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
   tor_free(set);
-  tt_int_op(contains, ==, 0);
+  tt_int_op(contains, OP_EQ, 0);
 
   done:
     ;
@@ -706,7 +706,7 @@ NS(test_main)(void *arg)
   contains = routerset_contains(set, NULL, 0, nickname, NULL, 0);
   routerset_free(set);
 
-  tt_int_op(contains, ==, 0);
+  tt_int_op(contains, OP_EQ, 0);
 
   done:
     ;
@@ -733,7 +733,7 @@ NS(test_main)(void *arg)
   contains = routerset_contains(set, NULL, 0, nickname, NULL, 0);
   routerset_free(set);
 
-  tt_int_op(contains, ==, 4);
+  tt_int_op(contains, OP_EQ, 4);
   done:
     ;
 }
@@ -757,7 +757,7 @@ NS(test_main)(void *arg)
   contains = routerset_contains(set, NULL, 0, "foo", NULL, 0);
   routerset_free(set);
 
-  tt_int_op(contains, ==, 0);
+  tt_int_op(contains, OP_EQ, 0);
   done:
     ;
 }
@@ -782,7 +782,7 @@ NS(test_main)(void *arg)
   contains = routerset_contains(set, NULL, 0, NULL, (const char*)foo, 0);
   routerset_free(set);
 
-  tt_int_op(contains, ==, 4);
+  tt_int_op(contains, OP_EQ, 4);
   done:
     ;
 }
@@ -808,7 +808,7 @@ NS(test_main)(void *arg)
   contains = routerset_contains(set, NULL, 0, NULL, (const char*)foo, 0);
   routerset_free(set);
 
-  tt_int_op(contains, ==, 0);
+  tt_int_op(contains, OP_EQ, 0);
   done:
     ;
 }
@@ -833,7 +833,7 @@ NS(test_main)(void *arg)
   contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
   routerset_free(set);
 
-  tt_int_op(contains, ==, 0);
+  tt_int_op(contains, OP_EQ, 0);
   done:
     ;
 }
@@ -865,8 +865,8 @@ NS(test_main)(void *arg)
   contains = routerset_contains(set, addr, 0, NULL, NULL, 0);
   routerset_free(set);
 
-  tt_int_op(CALLED(compare_tor_addr_to_addr_policy), ==, 1);
-  tt_int_op(contains, ==, 3);
+  tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
+  tt_int_op(contains, OP_EQ, 3);
 
   done:
     ;
@@ -879,7 +879,7 @@ NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
   (void)port;
   (void)policy;
   CALLED(compare_tor_addr_to_addr_policy)++;
-  tt_ptr_op(addr, ==, MOCK_TOR_ADDR_PTR);
+  tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
   return ADDR_POLICY_REJECTED;
 
   done:
@@ -910,8 +910,8 @@ NS(test_main)(void *arg)
   contains = routerset_contains(set, addr, 0, NULL, NULL, 0);
   routerset_free(set);
 
-  tt_int_op(CALLED(compare_tor_addr_to_addr_policy), ==, 1);
-  tt_int_op(contains, ==, 0);
+  tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
+  tt_int_op(contains, OP_EQ, 0);
 
   done:
     ;
@@ -924,7 +924,7 @@ NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
   (void)port;
   (void)policy;
   CALLED(compare_tor_addr_to_addr_policy)++;
-  tt_ptr_op(addr, ==, MOCK_TOR_ADDR_PTR);
+  tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
 
   return ADDR_POLICY_ACCEPTED;
 
@@ -955,7 +955,7 @@ NS(test_main)(void *arg)
   contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
   routerset_free(set);
 
-  tt_int_op(contains, ==, 0);
+  tt_int_op(contains, OP_EQ, 0);
 
   done:
     ;
@@ -968,7 +968,7 @@ NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
   (void)port;
   (void)policy;
   CALLED(compare_tor_addr_to_addr_policy)++;
-  tt_ptr_op(addr, ==, MOCK_TOR_ADDR_PTR);
+  tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
 
   return ADDR_POLICY_ACCEPTED;
 
@@ -1003,9 +1003,9 @@ NS(test_main)(void *arg)
   contains = routerset_contains(set, MOCK_TOR_ADDR_PTR, 0, NULL, NULL, -1);
   routerset_free(set);
 
-  tt_int_op(contains, ==, 0);
-  tt_int_op(CALLED(compare_tor_addr_to_addr_policy), ==, 1);
-  tt_int_op(CALLED(geoip_get_country_by_addr), ==, 1);
+  tt_int_op(contains, OP_EQ, 0);
+  tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
+  tt_int_op(CALLED(geoip_get_country_by_addr), OP_EQ, 1);
 
   done:
     ;
@@ -1018,7 +1018,7 @@ NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
   (void)port;
   (void)policy;
   CALLED(compare_tor_addr_to_addr_policy)++;
-  tt_ptr_op(addr, ==, MOCK_TOR_ADDR_PTR);
+  tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
 
   done:
     return ADDR_POLICY_ACCEPTED;
@@ -1028,7 +1028,7 @@ int
 NS(geoip_get_country_by_addr)(const tor_addr_t *addr)
 {
   CALLED(geoip_get_country_by_addr)++;
-  tt_ptr_op(addr, ==, MOCK_TOR_ADDR_PTR);
+  tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
 
   done:
     return -1;
@@ -1062,9 +1062,9 @@ NS(test_main)(void *arg)
   contains = routerset_contains(set, MOCK_TOR_ADDR_PTR, 0, NULL, NULL, -1);
   routerset_free(set);
 
-  tt_int_op(contains, ==, 2);
-  tt_int_op(CALLED(compare_tor_addr_to_addr_policy), ==, 1);
-  tt_int_op(CALLED(geoip_get_country_by_addr), ==, 1);
+  tt_int_op(contains, OP_EQ, 2);
+  tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
+  tt_int_op(CALLED(geoip_get_country_by_addr), OP_EQ, 1);
 
   done:
     ;
@@ -1077,7 +1077,7 @@ NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
   (void)port;
   (void)policy;
   CALLED(compare_tor_addr_to_addr_policy)++;
-  tt_ptr_op(addr, ==, MOCK_TOR_ADDR_PTR);
+  tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
 
   done:
     return ADDR_POLICY_ACCEPTED;
@@ -1087,7 +1087,7 @@ int
 NS(geoip_get_country_by_addr)(const tor_addr_t *addr)
 {
   CALLED(geoip_get_country_by_addr)++;
-  tt_ptr_op(addr, ==, MOCK_TOR_ADDR_PTR);
+  tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
 
   done:
     return 1;
@@ -1111,7 +1111,7 @@ NS(test_main)(void *arg)
 
   r = routerset_add_unknown_ccs(setp, 1);
 
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
 
   done:
     routerset_free(set);
@@ -1140,8 +1140,8 @@ NS(test_main)(void *arg)
 
   r = routerset_add_unknown_ccs(setp, 0);
 
-  tt_ptr_op(*setp, !=, NULL);
-  tt_int_op(r, ==, 0);
+  tt_ptr_op(*setp, OP_NE, NULL);
+  tt_int_op(r, OP_EQ, 0);
 
   done:
     if (set != NULL)
@@ -1181,9 +1181,9 @@ NS(test_main)(void *arg)
 
   r = routerset_add_unknown_ccs(setp, 0);
 
-  tt_int_op(r, ==, 1);
-  tt_int_op(smartlist_contains_string(set->country_names, "??"), ==, 1);
-  tt_int_op(smartlist_contains_string(set->list, "{??}"), ==, 1);
+  tt_int_op(r, OP_EQ, 1);
+  tt_int_op(smartlist_contains_string(set->country_names, "??"), OP_EQ, 1);
+  tt_int_op(smartlist_contains_string(set->list, "{??}"), OP_EQ, 1);
 
   done:
     if (set != NULL)
@@ -1200,7 +1200,7 @@ NS(geoip_get_country)(const char *country)
   arg_is_qq = !strcmp(country, "??");
   arg_is_a1 = !strcmp(country, "A1");
 
-  tt_int_op(arg_is_qq || arg_is_a1, ==, 1);
+  tt_int_op(arg_is_qq || arg_is_a1, OP_EQ, 1);
 
   if (arg_is_qq)
     return 1;
@@ -1214,7 +1214,7 @@ NS(geoip_is_loaded)(sa_family_t family)
 {
   CALLED(geoip_is_loaded)++;
 
-  tt_int_op(family, ==, AF_INET);
+  tt_int_op(family, OP_EQ, AF_INET);
 
   done:
     return 0;
@@ -1244,9 +1244,9 @@ NS(test_main)(void *arg)
 
   r = routerset_add_unknown_ccs(setp, 0);
 
-  tt_int_op(r, ==, 1);
-  tt_int_op(smartlist_contains_string(set->country_names, "a1"), ==, 1);
-  tt_int_op(smartlist_contains_string(set->list, "{a1}"), ==, 1);
+  tt_int_op(r, OP_EQ, 1);
+  tt_int_op(smartlist_contains_string(set->country_names, "a1"), OP_EQ, 1);
+  tt_int_op(smartlist_contains_string(set->list, "{a1}"), OP_EQ, 1);
 
   done:
     if (set != NULL)
@@ -1263,7 +1263,7 @@ NS(geoip_get_country)(const char *country)
   arg_is_qq = !strcmp(country, "??");
   arg_is_a1 = !strcmp(country, "A1");
 
-  tt_int_op(arg_is_qq || arg_is_a1, ==, 1);
+  tt_int_op(arg_is_qq || arg_is_a1, OP_EQ, 1);
 
   if (arg_is_a1)
     return 1;
@@ -1277,7 +1277,7 @@ NS(geoip_is_loaded)(sa_family_t family)
 {
   CALLED(geoip_is_loaded)++;
 
-  tt_int_op(family, ==, AF_INET);
+  tt_int_op(family, OP_EQ, AF_INET);
 
   done:
     return 0;
@@ -1306,7 +1306,7 @@ NS(test_main)(void *arg)
 
   r = routerset_contains_extendinfo(set, &ei);
 
-  tt_int_op(r, ==, 4);
+  tt_int_op(r, OP_EQ, 4);
   done:
     routerset_free(set);
 }
@@ -1334,7 +1334,7 @@ NS(test_main)(void *arg)
 
   r = routerset_contains_router(set, &ri, country);
 
-  tt_int_op(r, ==, 4);
+  tt_int_op(r, OP_EQ, 4);
   done:
     routerset_free(set);
 }
@@ -1367,7 +1367,7 @@ NS(test_main)(void *arg)
 
   r = routerset_contains_routerstatus(set, &rs, country);
 
-  tt_int_op(r, ==, 4);
+  tt_int_op(r, OP_EQ, 4);
   done:
     routerset_free(set);
 }
@@ -1393,7 +1393,7 @@ NS(test_main)(void *arg)
   NS(mock_node).rs = NULL;
 
   r = routerset_contains_node(set, &NS(mock_node));
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
 
   done:
     routerset_free(set);
@@ -1427,7 +1427,7 @@ NS(test_main)(void *arg)
 
   r = routerset_contains_node(set, &NS(mock_node));
 
-  tt_int_op(r, ==, 4);
+  tt_int_op(r, OP_EQ, 4);
   done:
     routerset_free(set);
 }
@@ -1458,7 +1458,7 @@ NS(test_main)(void *arg)
 
   r = routerset_contains_node(set, &mock_node);
 
-  tt_int_op(r, ==, 4);
+  tt_int_op(r, OP_EQ, 4);
   done:
     routerset_free(set);
 }
@@ -1478,15 +1478,15 @@ NS(test_main)(void *arg)
   routerset_t *set = NULL;
   (void)arg;
 
-  tt_int_op(smartlist_len(out), ==, 0);
+  tt_int_op(smartlist_len(out), OP_EQ, 0);
   routerset_get_all_nodes(out, NULL, NULL, 0);
 
-  tt_int_op(smartlist_len(out), ==, 0);
+  tt_int_op(smartlist_len(out), OP_EQ, 0);
 
   set = routerset_new();
   smartlist_free(set->list);
   routerset_get_all_nodes(out, NULL, NULL, 0);
-  tt_int_op(smartlist_len(out), ==, 0);
+  tt_int_op(smartlist_len(out), OP_EQ, 0);
 
   /* Just recreate list, so we can simply use routerset_free. */
   set->list = smartlist_new();
@@ -1527,8 +1527,8 @@ NS(test_main)(void *arg)
   smartlist_free(out);
   routerset_free(set);
 
-  tt_int_op(out_len, ==, 0);
-  tt_int_op(CALLED(node_get_by_nickname), ==, 1);
+  tt_int_op(out_len, OP_EQ, 0);
+  tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);
 
   done:
     ;
@@ -1538,8 +1538,8 @@ const node_t *
 NS(node_get_by_nickname)(const char *nickname, int warn_if_unused)
 {
   CALLED(node_get_by_nickname)++;
-  tt_str_op(nickname, ==, NS(mock_nickname));
-  tt_int_op(warn_if_unused, ==, 1);
+  tt_str_op(nickname, OP_EQ, NS(mock_nickname));
+  tt_int_op(warn_if_unused, OP_EQ, 1);
 
   done:
     return NULL;
@@ -1578,8 +1578,8 @@ NS(test_main)(void *arg)
   smartlist_free(out);
   routerset_free(set);
 
-  tt_int_op(out_len, ==, 0);
-  tt_int_op(CALLED(node_get_by_nickname), ==, 1);
+  tt_int_op(out_len, OP_EQ, 0);
+  tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);
 
   done:
     ;
@@ -1589,8 +1589,8 @@ const node_t *
 NS(node_get_by_nickname)(const char *nickname, int warn_if_unused)
 {
   CALLED(node_get_by_nickname)++;
-  tt_str_op(nickname, ==, NS(mock_nickname));
-  tt_int_op(warn_if_unused, ==, 1);
+  tt_str_op(nickname, OP_EQ, NS(mock_nickname));
+  tt_int_op(warn_if_unused, OP_EQ, 1);
 
   done:
     return &NS(mock_node);
@@ -1629,9 +1629,9 @@ NS(test_main)(void *arg)
   smartlist_free(out);
   routerset_free(set);
 
-  tt_int_op(out_len, ==, 1);
-  tt_ptr_op(ent, ==, &NS(mock_node));
-  tt_int_op(CALLED(node_get_by_nickname), ==, 1);
+  tt_int_op(out_len, OP_EQ, 1);
+  tt_ptr_op(ent, OP_EQ, &NS(mock_node));
+  tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);
 
   done:
     ;
@@ -1641,8 +1641,8 @@ const node_t *
 NS(node_get_by_nickname)(const char *nickname, int warn_if_unused)
 {
   CALLED(node_get_by_nickname)++;
-  tt_str_op(nickname, ==, NS(mock_nickname));
-  tt_int_op(warn_if_unused, ==, 1);
+  tt_str_op(nickname, OP_EQ, NS(mock_nickname));
+  tt_int_op(warn_if_unused, OP_EQ, 1);
 
   done:
     return &NS(mock_node);
@@ -1678,8 +1678,8 @@ NS(test_main)(void *arg)
   smartlist_free(out);
   smartlist_free(NS(mock_smartlist));
 
-  tt_int_op(r, ==, 0);
-  tt_int_op(CALLED(nodelist_get_list), ==, 1);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(CALLED(nodelist_get_list), OP_EQ, 1);
 
   done:
     ;
@@ -1727,8 +1727,8 @@ NS(test_main)(void *arg)
   smartlist_free(out);
   smartlist_free(NS(mock_smartlist));
 
-  tt_int_op(r, ==, 0);
-  tt_int_op(CALLED(nodelist_get_list), ==, 1);
+  tt_int_op(r, OP_EQ, 0);
+  tt_int_op(CALLED(nodelist_get_list), OP_EQ, 1);
 
   done:
     ;
@@ -1766,10 +1766,10 @@ NS(test_main)(void *arg)
   mock_node.ri = &ri;
   smartlist_add(list, (void *)&mock_node);
 
-  tt_int_op(smartlist_len(list), !=, 0);
+  tt_int_op(smartlist_len(list), OP_NE, 0);
   routerset_subtract_nodes(list, set);
 
-  tt_int_op(smartlist_len(list), ==, 0);
+  tt_int_op(smartlist_len(list), OP_EQ, 0);
   done:
     routerset_free(set);
     smartlist_free(list);
@@ -1796,10 +1796,10 @@ NS(test_main)(void *arg)
   mock_node.ri = &ri;
   smartlist_add(list, (void *)&mock_node);
 
-  tt_int_op(smartlist_len(list), !=, 0);
+  tt_int_op(smartlist_len(list), OP_NE, 0);
   routerset_subtract_nodes(list, set);
 
-  tt_int_op(smartlist_len(list), !=, 0);
+  tt_int_op(smartlist_len(list), OP_NE, 0);
   done:
     routerset_free(set);
     smartlist_free(list);
@@ -1821,19 +1821,19 @@ NS(test_main)(void *arg)
 
   set = NULL;
   s = routerset_to_string(set);
-  tt_str_op(s, ==, "");
+  tt_str_op(s, OP_EQ, "");
   tor_free(s);
 
   set = routerset_new();
   s = routerset_to_string(set);
-  tt_str_op(s, ==, "");
+  tt_str_op(s, OP_EQ, "");
   tor_free(s);
   routerset_free(set); set = NULL;
 
   set = routerset_new();
   smartlist_add(set->list, tor_strndup("a", 1));
   s = routerset_to_string(set);
-  tt_str_op(s, ==, "a");
+  tt_str_op(s, OP_EQ, "a");
   tor_free(s);
   routerset_free(set); set = NULL;
 
@@ -1841,7 +1841,7 @@ NS(test_main)(void *arg)
   smartlist_add(set->list, tor_strndup("a", 1));
   smartlist_add(set->list, tor_strndup("b", 1));
   s = routerset_to_string(set);
-  tt_str_op(s, ==, "a,b");
+  tt_str_op(s, OP_EQ, "a,b");
   tor_free(s);
   routerset_free(set); set = NULL;
 
@@ -1868,7 +1868,7 @@ NS(test_main)(void *arg)
   routerset_free(a);
   routerset_free(b);
 
-  tt_int_op(r, ==, 1);
+  tt_int_op(r, OP_EQ, 1);
 
   done:
     ;
@@ -1893,7 +1893,7 @@ NS(test_main)(void *arg)
   routerset_free(a);
   routerset_free(b);
 
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   done:
     ;
 }
@@ -1920,7 +1920,7 @@ NS(test_main)(void *arg)
   routerset_free(a);
   routerset_free(b);
 
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   done:
     ;
 }
@@ -1946,7 +1946,7 @@ NS(test_main)(void *arg)
   routerset_free(a);
   routerset_free(b);
 
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   done:
     ;
 }
@@ -1972,7 +1972,7 @@ NS(test_main)(void *arg)
   routerset_free(a);
   routerset_free(b);
 
-  tt_int_op(r, ==, 1);
+  tt_int_op(r, OP_EQ, 1);
   done:
     ;
 }
@@ -1995,7 +1995,7 @@ NS(test_main)(void *arg)
 
   routerset_free(NULL);
 
-  tt_int_op(CALLED(smartlist_free), ==, 0);
+  tt_int_op(CALLED(smartlist_free), OP_EQ, 0);
 
   done:
     ;
@@ -2031,9 +2031,9 @@ NS(test_main)(void *arg)
 
   routerset_free(routerset);
 
-  tt_int_op(CALLED(smartlist_free), !=, 0);
-  tt_int_op(CALLED(strmap_free), !=, 0);
-  tt_int_op(CALLED(digestmap_free), !=, 0);
+  tt_int_op(CALLED(smartlist_free), OP_NE, 0);
+  tt_int_op(CALLED(strmap_free), OP_NE, 0);
+  tt_int_op(CALLED(digestmap_free), OP_NE, 0);
 
   done:
     ;
diff --git a/src/test/test_socks.c b/src/test/test_socks.c
index 29faa69..98c5be0 100644
--- a/src/test/test_socks.c
+++ b/src/test/test_socks.c
@@ -63,8 +63,8 @@ test_socks_4_unsupported_commands(void *ptr)
   ADD_DATA(buf, "\x04\x02\x11\x11\x02\x02\x02\x02\x00");
   tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
                                    get_options()->SafeSocks) == -1);
-  tt_int_op(4,==, socks->socks_version);
-  tt_int_op(0,==, socks->replylen); /* XXX: shouldn't tor reply? */
+  tt_int_op(4,OP_EQ, socks->socks_version);
+  tt_int_op(0,OP_EQ, socks->replylen); /* XXX: shouldn't tor reply? */
 
  done:
   ;
@@ -76,49 +76,49 @@ test_socks_4_supported_commands(void *ptr)
 {
   SOCKS_TEST_INIT();
 
-  tt_int_op(0,==, buf_datalen(buf));
+  tt_int_op(0,OP_EQ, 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");
   tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
                                    get_options()->SafeSocks) == 1);
-  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_int_op(4,OP_EQ, socks->socks_version);
+  tt_int_op(0,OP_EQ, socks->replylen); /* XXX: shouldn't tor reply? */
+  tt_int_op(SOCKS_COMMAND_CONNECT,OP_EQ, socks->command);
+  tt_str_op("2.2.2.3",OP_EQ, socks->address);
+  tt_int_op(4370,OP_EQ, socks->port);
   tt_assert(socks->got_auth == 0);
   tt_assert(! socks->username);
 
-  tt_int_op(0,==, buf_datalen(buf));
+  tt_int_op(0,OP_EQ, 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");
   tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
                                    get_options()->SafeSocks) == 1);
-  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_int_op(4,OP_EQ, socks->socks_version);
+  tt_int_op(0,OP_EQ, socks->replylen); /* XXX: shouldn't tor reply? */
+  tt_int_op(SOCKS_COMMAND_CONNECT,OP_EQ, socks->command);
+  tt_str_op("2.2.2.4",OP_EQ, socks->address);
+  tt_int_op(4370,OP_EQ, 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);
+  tt_int_op(2,OP_EQ, socks->usernamelen);
+  tt_mem_op("me",OP_EQ, socks->username, 2);
 
-  tt_int_op(0,==, buf_datalen(buf));
+  tt_int_op(0,OP_EQ, 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");
   tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
                                    get_options()->SafeSocks) == 1);
-  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);
+  tt_int_op(4,OP_EQ, socks->socks_version);
+  tt_int_op(0,OP_EQ, socks->replylen); /* XXX: shouldn't tor reply? */
+  tt_str_op("torproject.org",OP_EQ, socks->address);
 
-  tt_int_op(0,==, buf_datalen(buf));
+  tt_int_op(0,OP_EQ, buf_datalen(buf));
 
  done:
   ;
@@ -134,21 +134,21 @@ test_socks_5_unsupported_commands(void *ptr)
   ADD_DATA(buf, "\x05\x02\x00\x01");
 
   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]);
+                               get_options()->SafeSocks),OP_EQ, 0);
+  tt_int_op(0,OP_EQ, buf_datalen(buf));
+  tt_int_op(5,OP_EQ, socks->socks_version);
+  tt_int_op(2,OP_EQ, socks->replylen);
+  tt_int_op(5,OP_EQ, socks->reply[0]);
+  tt_int_op(0,OP_EQ, socks->reply[1]);
   ADD_DATA(buf, "\x05\x02\x00\x01\x02\x02\x02\x01\x01\x01");
   tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
-                               get_options()->SafeSocks),==, -1);
+                               get_options()->SafeSocks),OP_EQ, -1);
 
-  tt_int_op(5,==,socks->socks_version);
-  tt_int_op(10,==,socks->replylen);
-  tt_int_op(5,==,socks->reply[0]);
-  tt_int_op(SOCKS5_COMMAND_NOT_SUPPORTED,==,socks->reply[1]);
-  tt_int_op(1,==,socks->reply[3]);
+  tt_int_op(5,OP_EQ,socks->socks_version);
+  tt_int_op(10,OP_EQ,socks->replylen);
+  tt_int_op(5,OP_EQ,socks->reply[0]);
+  tt_int_op(SOCKS5_COMMAND_NOT_SUPPORTED,OP_EQ,socks->reply[1]);
+  tt_int_op(1,OP_EQ,socks->reply[3]);
 
   buf_clear(buf);
   socks_request_clear(socks);
@@ -156,20 +156,20 @@ test_socks_5_unsupported_commands(void *ptr)
   /* SOCKS 5 Send unsupported UDP_ASSOCIATE [03] command */
   ADD_DATA(buf, "\x05\x02\x00\x01");
   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]);
+                               get_options()->SafeSocks),OP_EQ, 0);
+  tt_int_op(5,OP_EQ, socks->socks_version);
+  tt_int_op(2,OP_EQ, socks->replylen);
+  tt_int_op(5,OP_EQ, socks->reply[0]);
+  tt_int_op(0,OP_EQ, socks->reply[1]);
   ADD_DATA(buf, "\x05\x03\x00\x01\x02\x02\x02\x01\x01\x01");
   tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
-                               get_options()->SafeSocks),==, -1);
+                               get_options()->SafeSocks),OP_EQ, -1);
 
-  tt_int_op(5,==,socks->socks_version);
-  tt_int_op(10,==,socks->replylen);
-  tt_int_op(5,==,socks->reply[0]);
-  tt_int_op(SOCKS5_COMMAND_NOT_SUPPORTED,==,socks->reply[1]);
-  tt_int_op(1,==,socks->reply[3]);
+  tt_int_op(5,OP_EQ,socks->socks_version);
+  tt_int_op(10,OP_EQ,socks->replylen);
+  tt_int_op(5,OP_EQ,socks->reply[0]);
+  tt_int_op(SOCKS5_COMMAND_NOT_SUPPORTED,OP_EQ,socks->reply[1]);
+  tt_int_op(1,OP_EQ,socks->reply[3]);
 
  done:
   ;
@@ -184,35 +184,35 @@ 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");
   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]);
+                                   get_options()->SafeSocks),OP_EQ, 0);
+  tt_int_op(5,OP_EQ, socks->socks_version);
+  tt_int_op(2,OP_EQ, socks->replylen);
+  tt_int_op(5,OP_EQ, socks->reply[0]);
+  tt_int_op(0,OP_EQ, socks->reply[1]);
 
   ADD_DATA(buf, "\x05\x01\x00\x01\x02\x02\x02\x02\x11\x11");
   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);
+                                   get_options()->SafeSocks),OP_EQ, 1);
+  tt_str_op("2.2.2.2",OP_EQ, socks->address);
+  tt_int_op(4369,OP_EQ, socks->port);
 
-  tt_int_op(0,==, buf_datalen(buf));
+  tt_int_op(0,OP_EQ, 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");
   tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
-                                   get_options()->SafeSocks),==, 1);
+                                   get_options()->SafeSocks),OP_EQ, 1);
 
-  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);
+  tt_int_op(5,OP_EQ, socks->socks_version);
+  tt_int_op(2,OP_EQ, socks->replylen);
+  tt_int_op(5,OP_EQ, socks->reply[0]);
+  tt_int_op(0,OP_EQ, socks->reply[1]);
+  tt_str_op("torproject.org",OP_EQ, socks->address);
+  tt_int_op(4369,OP_EQ, socks->port);
 
-  tt_int_op(0,==, buf_datalen(buf));
+  tt_int_op(0,OP_EQ, buf_datalen(buf));
   socks_request_clear(socks);
 
   /* SOCKS 5 Send RESOLVE [F0] request for torproject.org:4369 */
@@ -220,13 +220,13 @@ test_socks_5_supported_commands(void *ptr)
   ADD_DATA(buf, "\x05\xF0\x00\x03\x0Etorproject.org\x01\x02");
   tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
                                    get_options()->SafeSocks) == 1);
-  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(5,OP_EQ, socks->socks_version);
+  tt_int_op(2,OP_EQ, socks->replylen);
+  tt_int_op(5,OP_EQ, socks->reply[0]);
+  tt_int_op(0,OP_EQ, socks->reply[1]);
+  tt_str_op("torproject.org",OP_EQ, socks->address);
 
-  tt_int_op(0,==, buf_datalen(buf));
+  tt_int_op(0,OP_EQ, buf_datalen(buf));
   socks_request_clear(socks);
 
   /* SOCKS 5 Should reject RESOLVE [F0] request for IPv4 address
@@ -239,11 +239,11 @@ test_socks_5_supported_commands(void *ptr)
   tt_assert(fetch_from_buf_socks(buf,socks,get_options()->TestSocks,1)
             == -1);
 
-  tt_int_op(5,==,socks->socks_version);
-  tt_int_op(10,==,socks->replylen);
-  tt_int_op(5,==,socks->reply[0]);
-  tt_int_op(SOCKS5_NOT_ALLOWED,==,socks->reply[1]);
-  tt_int_op(1,==,socks->reply[3]);
+  tt_int_op(5,OP_EQ,socks->socks_version);
+  tt_int_op(10,OP_EQ,socks->replylen);
+  tt_int_op(5,OP_EQ,socks->reply[0]);
+  tt_int_op(SOCKS5_NOT_ALLOWED,OP_EQ,socks->reply[1]);
+  tt_int_op(1,OP_EQ,socks->reply[3]);
 
   socks_request_clear(socks);
 
@@ -257,11 +257,11 @@ test_socks_5_supported_commands(void *ptr)
   tt_assert(fetch_from_buf_socks(buf,socks,get_options()->TestSocks,1)
             == -1);
 
-  tt_int_op(5,==,socks->socks_version);
-  tt_int_op(10,==,socks->replylen);
-  tt_int_op(5,==,socks->reply[0]);
-  tt_int_op(SOCKS5_NOT_ALLOWED,==,socks->reply[1]);
-  tt_int_op(1,==,socks->reply[3]);
+  tt_int_op(5,OP_EQ,socks->socks_version);
+  tt_int_op(10,OP_EQ,socks->replylen);
+  tt_int_op(5,OP_EQ,socks->reply[0]);
+  tt_int_op(SOCKS5_NOT_ALLOWED,OP_EQ,socks->reply[1]);
+  tt_int_op(1,OP_EQ,socks->reply[3]);
 
   socks_request_clear(socks);
 
@@ -270,13 +270,13 @@ test_socks_5_supported_commands(void *ptr)
   ADD_DATA(buf, "\x05\xF1\x00\x01\x02\x02\x02\x05\x01\x03");
   tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
                                    get_options()->SafeSocks) == 1);
-  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);
+  tt_int_op(5,OP_EQ, socks->socks_version);
+  tt_int_op(2,OP_EQ, socks->replylen);
+  tt_int_op(5,OP_EQ, socks->reply[0]);
+  tt_int_op(0,OP_EQ, socks->reply[1]);
+  tt_str_op("2.2.2.5",OP_EQ, socks->address);
 
-  tt_int_op(0,==, buf_datalen(buf));
+  tt_int_op(0,OP_EQ, buf_datalen(buf));
 
  done:
   ;
@@ -293,27 +293,27 @@ test_socks_5_no_authenticate(void *ptr)
   tt_assert(!fetch_from_buf_socks(buf, socks,
                                     get_options()->TestSocks,
                                     get_options()->SafeSocks));
-  tt_int_op(2,==, socks->replylen);
-  tt_int_op(5,==, socks->reply[0]);
-  tt_int_op(SOCKS_NO_AUTH,==, socks->reply[1]);
+  tt_int_op(2,OP_EQ, socks->replylen);
+  tt_int_op(5,OP_EQ, socks->reply[0]);
+  tt_int_op(SOCKS_NO_AUTH,OP_EQ, socks->reply[1]);
 
-  tt_int_op(0,==, buf_datalen(buf));
+  tt_int_op(0,OP_EQ, buf_datalen(buf));
 
   /*SOCKS 5 Send username/password anyway - pretend to be broken */
   ADD_DATA(buf,"\x01\x02\x01\x01\x02\x01\x01");
   tt_assert(!fetch_from_buf_socks(buf, socks,
                                     get_options()->TestSocks,
                                     get_options()->SafeSocks));
-  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]);
+  tt_int_op(5,OP_EQ, socks->socks_version);
+  tt_int_op(2,OP_EQ, socks->replylen);
+  tt_int_op(1,OP_EQ, socks->reply[0]);
+  tt_int_op(0,OP_EQ, socks->reply[1]);
 
-  tt_int_op(2,==, socks->usernamelen);
-  tt_int_op(2,==, socks->passwordlen);
+  tt_int_op(2,OP_EQ, socks->usernamelen);
+  tt_int_op(2,OP_EQ, socks->passwordlen);
 
-  tt_mem_op("\x01\x01",==, socks->username, 2);
-  tt_mem_op("\x01\x01",==, socks->password, 2);
+  tt_mem_op("\x01\x01",OP_EQ, socks->username, 2);
+  tt_mem_op("\x01\x01",OP_EQ, socks->password, 2);
 
  done:
   ;
@@ -331,28 +331,28 @@ test_socks_5_authenticate(void *ptr)
   tt_assert(!fetch_from_buf_socks(buf, socks,
                                    get_options()->TestSocks,
                                    get_options()->SafeSocks));
-  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);
+  tt_int_op(2,OP_EQ, socks->replylen);
+  tt_int_op(5,OP_EQ, socks->reply[0]);
+  tt_int_op(SOCKS_USER_PASS,OP_EQ, socks->reply[1]);
+  tt_int_op(5,OP_EQ, socks->socks_version);
 
-  tt_int_op(0,==, buf_datalen(buf));
+  tt_int_op(0,OP_EQ, buf_datalen(buf));
 
   /* SOCKS 5 Send username/password */
   ADD_DATA(buf, "\x01\x02me\x08mypasswd");
   tt_assert(!fetch_from_buf_socks(buf, socks,
                                    get_options()->TestSocks,
                                    get_options()->SafeSocks));
-  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]);
+  tt_int_op(5,OP_EQ, socks->socks_version);
+  tt_int_op(2,OP_EQ, socks->replylen);
+  tt_int_op(1,OP_EQ, socks->reply[0]);
+  tt_int_op(0,OP_EQ, socks->reply[1]);
 
-  tt_int_op(2,==, socks->usernamelen);
-  tt_int_op(8,==, socks->passwordlen);
+  tt_int_op(2,OP_EQ, socks->usernamelen);
+  tt_int_op(8,OP_EQ, socks->passwordlen);
 
-  tt_mem_op("me",==, socks->username, 2);
-  tt_mem_op("mypasswd",==, socks->password, 8);
+  tt_mem_op("me",OP_EQ, socks->username, 2);
+  tt_mem_op("mypasswd",OP_EQ, socks->password, 8);
 
  done:
   ;
@@ -370,12 +370,12 @@ test_socks_5_authenticate_with_data(void *ptr)
   tt_assert(!fetch_from_buf_socks(buf, socks,
                                    get_options()->TestSocks,
                                    get_options()->SafeSocks));
-  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);
+  tt_int_op(2,OP_EQ, socks->replylen);
+  tt_int_op(5,OP_EQ, socks->reply[0]);
+  tt_int_op(SOCKS_USER_PASS,OP_EQ, socks->reply[1]);
+  tt_int_op(5,OP_EQ, socks->socks_version);
 
-  tt_int_op(0,==, buf_datalen(buf));
+  tt_int_op(0,OP_EQ, buf_datalen(buf));
 
   /* SOCKS 5 Send username/password */
   /* SOCKS 5 Send CONNECT [01] to IP address 2.2.2.2:4369 */
@@ -383,18 +383,18 @@ test_socks_5_authenticate_with_data(void *ptr)
   tt_assert(fetch_from_buf_socks(buf, socks,
                                    get_options()->TestSocks,
                                    get_options()->SafeSocks) == 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]);
+  tt_int_op(5,OP_EQ, socks->socks_version);
+  tt_int_op(2,OP_EQ, socks->replylen);
+  tt_int_op(1,OP_EQ, socks->reply[0]);
+  tt_int_op(0,OP_EQ, socks->reply[1]);
 
-  tt_str_op("2.2.2.2",==, socks->address);
-  tt_int_op(4369,==, socks->port);
+  tt_str_op("2.2.2.2",OP_EQ, socks->address);
+  tt_int_op(4369,OP_EQ, socks->port);
 
-  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);
+  tt_int_op(2,OP_EQ, socks->usernamelen);
+  tt_int_op(3,OP_EQ, socks->passwordlen);
+  tt_mem_op("me",OP_EQ, socks->username, 2);
+  tt_mem_op("you",OP_EQ, socks->password, 3);
 
  done:
   ;
@@ -411,10 +411,10 @@ test_socks_5_auth_before_negotiation(void *ptr)
   tt_assert(fetch_from_buf_socks(buf, socks,
                                    get_options()->TestSocks,
                                    get_options()->SafeSocks) == -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]);
+  tt_int_op(0,OP_EQ, socks->socks_version);
+  tt_int_op(0,OP_EQ, socks->replylen);
+  tt_int_op(0,OP_EQ, socks->reply[0]);
+  tt_int_op(0,OP_EQ, socks->reply[1]);
 
  done:
   ;
@@ -432,14 +432,14 @@ test_socks_5_malformed_commands(void *ptr)
    */
   ADD_DATA(buf, "\x05\x01\x00");
   ADD_DATA(buf, "\x05\x01\x00\x01\x02\x02\x02\x02\x11\x11");
-  tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, 1),==,
+  tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, 1),OP_EQ,
                                  -1);
 
-  tt_int_op(5,==,socks->socks_version);
-  tt_int_op(10,==,socks->replylen);
-  tt_int_op(5,==,socks->reply[0]);
-  tt_int_op(SOCKS5_NOT_ALLOWED,==,socks->reply[1]);
-  tt_int_op(1,==,socks->reply[3]);
+  tt_int_op(5,OP_EQ,socks->socks_version);
+  tt_int_op(10,OP_EQ,socks->replylen);
+  tt_int_op(5,OP_EQ,socks->reply[0]);
+  tt_int_op(SOCKS5_NOT_ALLOWED,OP_EQ,socks->reply[1]);
+  tt_int_op(1,OP_EQ,socks->reply[3]);
 
   buf_clear(buf);
   socks_request_clear(socks);
@@ -448,13 +448,13 @@ test_socks_5_malformed_commands(void *ptr)
   ADD_DATA(buf, "\x05\x01\x00");
   ADD_DATA(buf, "\x05\xF1\x00\x03\x0Etorproject.org\x11\x11");
   tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
-                                   get_options()->SafeSocks),==, -1);
+                                   get_options()->SafeSocks),OP_EQ, -1);
 
-  tt_int_op(5,==,socks->socks_version);
-  tt_int_op(10,==,socks->replylen);
-  tt_int_op(5,==,socks->reply[0]);
-  tt_int_op(SOCKS5_ADDRESS_TYPE_NOT_SUPPORTED,==,socks->reply[1]);
-  tt_int_op(1,==,socks->reply[3]);
+  tt_int_op(5,OP_EQ,socks->socks_version);
+  tt_int_op(10,OP_EQ,socks->replylen);
+  tt_int_op(5,OP_EQ,socks->reply[0]);
+  tt_int_op(SOCKS5_ADDRESS_TYPE_NOT_SUPPORTED,OP_EQ,socks->reply[1]);
+  tt_int_op(1,OP_EQ,socks->reply[3]);
 
   buf_clear(buf);
   socks_request_clear(socks);
@@ -465,13 +465,13 @@ test_socks_5_malformed_commands(void *ptr)
   ADD_DATA(buf, "\x05\x01\x00");
   ADD_DATA(buf, "\x05\x01\x00\x03\x09\"\"\"\"\".com\x11\x11");
   tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
-                                   get_options()->SafeSocks),==, -1);
+                                   get_options()->SafeSocks),OP_EQ, -1);
 
-  tt_int_op(5,==,socks->socks_version);
-  tt_int_op(10,==,socks->replylen);
-  tt_int_op(5,==,socks->reply[0]);
-  tt_int_op(SOCKS5_GENERAL_ERROR,==,socks->reply[1]);
-  tt_int_op(1,==,socks->reply[3]);
+  tt_int_op(5,OP_EQ,socks->socks_version);
+  tt_int_op(10,OP_EQ,socks->replylen);
+  tt_int_op(5,OP_EQ,socks->reply[0]);
+  tt_int_op(SOCKS5_GENERAL_ERROR,OP_EQ,socks->reply[1]);
+  tt_int_op(1,OP_EQ,socks->reply[3]);
 
   buf_clear(buf);
   socks_request_clear(socks);
@@ -480,13 +480,13 @@ test_socks_5_malformed_commands(void *ptr)
   ADD_DATA(buf, "\x05\x01\x00");
   ADD_DATA(buf, "\x05\x01\x00\x23\x02\x02\x02\x02\x11\x11");
   tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks,
-                                   get_options()->SafeSocks),==, -1);
+                                   get_options()->SafeSocks),OP_EQ, -1);
 
-  tt_int_op(5,==,socks->socks_version);
-  tt_int_op(10,==,socks->replylen);
-  tt_int_op(5,==,socks->reply[0]);
-  tt_int_op(SOCKS5_ADDRESS_TYPE_NOT_SUPPORTED,==,socks->reply[1]);
-  tt_int_op(1,==,socks->reply[3]);
+  tt_int_op(5,OP_EQ,socks->socks_version);
+  tt_int_op(10,OP_EQ,socks->replylen);
+  tt_int_op(5,OP_EQ,socks->reply[0]);
+  tt_int_op(SOCKS5_ADDRESS_TYPE_NOT_SUPPORTED,OP_EQ,socks->reply[1]);
+  tt_int_op(1,OP_EQ,socks->reply[3]);
 
  done:
   ;
diff --git a/src/test/test_status.c b/src/test/test_status.c
index 8bc0152..dd825f2 100644
--- a/src/test/test_status.c
+++ b/src/test/test_status.c
@@ -86,62 +86,62 @@ NS(test_main)(void *arg)
 
   expected = "0:00 hours";
   actual = secs_to_uptime(0);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "0:00 hours";
   actual = secs_to_uptime(1);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "0:01 hours";
   actual = secs_to_uptime(60);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "0:59 hours";
   actual = secs_to_uptime(60 * 59);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "1:00 hours";
   actual = secs_to_uptime(60 * 60);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "23:59 hours";
   actual = secs_to_uptime(60 * 60 * 23 + 60 * 59);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "1 day 0:00 hours";
   actual = secs_to_uptime(60 * 60 * 23 + 60 * 60);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "1 day 0:00 hours";
   actual = secs_to_uptime(86400 + 1);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "1 day 0:01 hours";
   actual = secs_to_uptime(86400 + 60);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "10 days 0:00 hours";
   actual = secs_to_uptime(86400 * 10);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "10 days 0:00 hours";
   actual = secs_to_uptime(864000 + 1);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "10 days 0:01 hours";
   actual = secs_to_uptime(864000 + 60);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   done:
@@ -167,62 +167,62 @@ NS(test_main)(void *arg)
 
   expected = "0 kB";
   actual = bytes_to_usage(0);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "0 kB";
   actual = bytes_to_usage(1);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "1 kB";
   actual = bytes_to_usage(1024);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "1023 kB";
   actual = bytes_to_usage((1 << 20) - 1);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "1.00 MB";
   actual = bytes_to_usage((1 << 20));
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "1.00 MB";
   actual = bytes_to_usage((1 << 20) + 5242);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "1.01 MB";
   actual = bytes_to_usage((1 << 20) + 5243);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "1024.00 MB";
   actual = bytes_to_usage((1 << 30) - 1);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "1.00 GB";
   actual = bytes_to_usage((1 << 30));
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "1.00 GB";
   actual = bytes_to_usage((1 << 30) + 5368709);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "1.01 GB";
   actual = bytes_to_usage((1 << 30) + 5368710);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   expected = "10.00 GB";
   actual = bytes_to_usage((U64_LITERAL(1) << 30) * 10L);
-  tt_str_op(actual, ==, expected);
+  tt_str_op(actual, OP_EQ, expected);
   tor_free(actual);
 
   done:
@@ -259,7 +259,7 @@ NS(test_main)(void *arg)
   expected = -1;
   actual = log_heartbeat(0);
 
-  tt_int_op(actual, ==, expected);
+  tt_int_op(actual, OP_EQ, expected);
 
   done:
     NS_UNMOCK(tls_get_write_overhead_ratio);
@@ -347,8 +347,8 @@ NS(test_main)(void *arg)
   expected = 0;
   actual = log_heartbeat(0);
 
-  tt_int_op(actual, ==, expected);
-  tt_int_op(CALLED(logv), ==, 3);
+  tt_int_op(actual, OP_EQ, expected);
+  tt_int_op(CALLED(logv), OP_EQ, 3);
 
   done:
     NS_UNMOCK(tls_get_write_overhead_ratio);
@@ -411,39 +411,39 @@ NS(logv)(int severity, log_domain_mask_t domain,
   switch (CALLED(logv))
   {
     case 0:
-      tt_int_op(severity, ==, LOG_NOTICE);
-      tt_int_op(domain, ==, LD_HEARTBEAT);
-      tt_ptr_op(strstr(funcname, "log_heartbeat"), !=, NULL);
-      tt_ptr_op(suffix, ==, NULL);
-      tt_str_op(format, ==,
+      tt_int_op(severity, OP_EQ, LOG_NOTICE);
+      tt_int_op(domain, OP_EQ, LD_HEARTBEAT);
+      tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL);
+      tt_ptr_op(suffix, OP_EQ, NULL);
+      tt_str_op(format, OP_EQ,
           "Heartbeat: It seems like we are not in the cached consensus.");
       break;
     case 1:
-      tt_int_op(severity, ==, LOG_NOTICE);
-      tt_int_op(domain, ==, LD_HEARTBEAT);
-      tt_ptr_op(strstr(funcname, "log_heartbeat"), !=, NULL);
-      tt_ptr_op(suffix, ==, NULL);
-      tt_str_op(format, ==,
+      tt_int_op(severity, OP_EQ, LOG_NOTICE);
+      tt_int_op(domain, OP_EQ, LD_HEARTBEAT);
+      tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL);
+      tt_ptr_op(suffix, OP_EQ, NULL);
+      tt_str_op(format, OP_EQ,
           "Heartbeat: Tor's uptime is %s, with %d circuits open. "
           "I've sent %s and received %s.%s");
-      tt_str_op(va_arg(ap, char *), ==, "0:00 hours");  /* uptime */
-      tt_int_op(va_arg(ap, int), ==, 0);  /* count_circuits() */
-      tt_str_op(va_arg(ap, char *), ==, "0 kB");  /* bw_sent */
-      tt_str_op(va_arg(ap, char *), ==, "0 kB");  /* bw_rcvd */
-      tt_str_op(va_arg(ap, char *), ==, "");  /* hibernating */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0:00 hours");  /* uptime */
+      tt_int_op(va_arg(ap, int), OP_EQ, 0);  /* count_circuits() */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB");  /* bw_sent */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB");  /* bw_rcvd */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "");  /* hibernating */
       break;
     case 2:
-      tt_int_op(severity, ==, LOG_NOTICE);
-      tt_int_op(domain, ==, LD_HEARTBEAT);
+      tt_int_op(severity, OP_EQ, LOG_NOTICE);
+      tt_int_op(domain, OP_EQ, LD_HEARTBEAT);
       tt_ptr_op(
-          strstr(funcname, "rep_hist_log_circuit_handshake_stats"), !=, NULL);
-      tt_ptr_op(suffix, ==, NULL);
-      tt_str_op(format, ==,
+          strstr(funcname, "rep_hist_log_circuit_handshake_stats"), OP_NE, NULL);
+      tt_ptr_op(suffix, OP_EQ, NULL);
+      tt_str_op(format, OP_EQ,
         "Circuit handshake stats since last time: %d/%d TAP, %d/%d NTor.");
-      tt_int_op(va_arg(ap, int), ==, 1);  /* handshakes assigned (TAP) */
-      tt_int_op(va_arg(ap, int), ==, 1);  /* handshakes requested (TAP) */
-      tt_int_op(va_arg(ap, int), ==, 1);  /* handshakes assigned (NTOR) */
-      tt_int_op(va_arg(ap, int), ==, 1);  /* handshakes requested (NTOR) */
+      tt_int_op(va_arg(ap, int), OP_EQ, 1);  /* handshakes assigned (TAP) */
+      tt_int_op(va_arg(ap, int), OP_EQ, 1);  /* handshakes requested (TAP) */
+      tt_int_op(va_arg(ap, int), OP_EQ, 1);  /* handshakes assigned (NTOR) */
+      tt_int_op(va_arg(ap, int), OP_EQ, 1);  /* handshakes requested (NTOR) */
       break;
     default:
       tt_abort_msg("unexpected call to logv()");  // TODO: prettyprint args
@@ -502,7 +502,7 @@ NS(test_main)(void *arg)
   expected = 0;
   actual = log_heartbeat(0);
 
-  tt_int_op(actual, ==, expected);
+  tt_int_op(actual, OP_EQ, expected);
 
   done:
     NS_UNMOCK(tls_get_write_overhead_ratio);
@@ -564,18 +564,18 @@ static void
 NS(logv)(int severity, log_domain_mask_t domain, const char *funcname,
   const char *suffix, const char *format, va_list ap)
 {
-  tt_int_op(severity, ==, LOG_NOTICE);
-  tt_int_op(domain, ==, LD_HEARTBEAT);
-  tt_ptr_op(strstr(funcname, "log_heartbeat"), !=, NULL);
-  tt_ptr_op(suffix, ==, NULL);
-  tt_str_op(format, ==,
+  tt_int_op(severity, OP_EQ, LOG_NOTICE);
+  tt_int_op(domain, OP_EQ, LD_HEARTBEAT);
+  tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL);
+  tt_ptr_op(suffix, OP_EQ, NULL);
+  tt_str_op(format, OP_EQ,
       "Heartbeat: Tor's uptime is %s, with %d circuits open. "
       "I've sent %s and received %s.%s");
-  tt_str_op(va_arg(ap, char *), ==, "0:00 hours");  /* uptime */
-  tt_int_op(va_arg(ap, int), ==, 0);  /* count_circuits() */
-  tt_str_op(va_arg(ap, char *), ==, "0 kB");  /* bw_sent */
-  tt_str_op(va_arg(ap, char *), ==, "0 kB");  /* bw_rcvd */
-  tt_str_op(va_arg(ap, char *), ==, " We are currently hibernating.");
+  tt_str_op(va_arg(ap, char *), OP_EQ, "0:00 hours");  /* uptime */
+  tt_int_op(va_arg(ap, int), OP_EQ, 0);  /* count_circuits() */
+  tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB");  /* bw_sent */
+  tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB");  /* bw_rcvd */
+  tt_str_op(va_arg(ap, char *), OP_EQ, " We are currently hibernating.");
 
   done:
     ;
@@ -638,8 +638,8 @@ NS(test_main)(void *arg)
   expected = 0;
   actual = log_heartbeat(0);
 
-  tt_int_op(actual, ==, expected);
-  tt_int_op(CALLED(logv), ==, 2);
+  tt_int_op(actual, OP_EQ, expected);
+  tt_int_op(CALLED(logv), OP_EQ, 2);
 
   done:
     NS_UNMOCK(tls_get_write_overhead_ratio);
@@ -711,34 +711,34 @@ NS(logv)(int severity, log_domain_mask_t domain,
   switch (CALLED(logv))
   {
     case 0:
-      tt_int_op(severity, ==, LOG_NOTICE);
-      tt_int_op(domain, ==, LD_HEARTBEAT);
-      tt_ptr_op(strstr(funcname, "log_heartbeat"), !=, NULL);
-      tt_ptr_op(suffix, ==, NULL);
-      tt_str_op(format, ==,
+      tt_int_op(severity, OP_EQ, LOG_NOTICE);
+      tt_int_op(domain, OP_EQ, LD_HEARTBEAT);
+      tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL);
+      tt_ptr_op(suffix, OP_EQ, NULL);
+      tt_str_op(format, OP_EQ,
           "Heartbeat: Tor's uptime is %s, with %d circuits open. "
           "I've sent %s and received %s.%s");
-      tt_str_op(va_arg(ap, char *), ==, "0:00 hours");  /* uptime */
-      tt_int_op(va_arg(ap, int), ==, 0);  /* count_circuits() */
-      tt_str_op(va_arg(ap, char *), ==, "0 kB");  /* bw_sent */
-      tt_str_op(va_arg(ap, char *), ==, "0 kB");  /* bw_rcvd */
-      tt_str_op(va_arg(ap, char *), ==, "");  /* hibernating */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0:00 hours");  /* uptime */
+      tt_int_op(va_arg(ap, int), OP_EQ, 0);  /* count_circuits() */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB");  /* bw_sent */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB");  /* bw_rcvd */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "");  /* hibernating */
       break;
     case 1:
-      tt_int_op(severity, ==, LOG_NOTICE);
-      tt_int_op(domain, ==, LD_HEARTBEAT);
-      tt_ptr_op(strstr(funcname, "log_accounting"), !=, NULL);
-      tt_ptr_op(suffix, ==, NULL);
-      tt_str_op(format, ==,
+      tt_int_op(severity, OP_EQ, LOG_NOTICE);
+      tt_int_op(domain, OP_EQ, LD_HEARTBEAT);
+      tt_ptr_op(strstr(funcname, "log_accounting"), OP_NE, NULL);
+      tt_ptr_op(suffix, OP_EQ, NULL);
+      tt_str_op(format, OP_EQ,
           "Heartbeat: Accounting enabled. Sent: %s / %s, Received: %s / %s. "
           "The current accounting interval ends on %s, in %s.");
-      tt_str_op(va_arg(ap, char *), ==, "0 kB");  /* acc_sent */
-      tt_str_op(va_arg(ap, char *), ==, "0 kB");  /* acc_max */
-      tt_str_op(va_arg(ap, char *), ==, "0 kB");  /* acc_rcvd */
-      tt_str_op(va_arg(ap, char *), ==, "0 kB");  /* acc_max */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB");  /* acc_sent */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB");  /* acc_max */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB");  /* acc_rcvd */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB");  /* acc_max */
       /* format_local_iso_time uses local tz, just check mins and secs. */
-      tt_ptr_op(strstr(va_arg(ap, char *), ":01:00"), !=, NULL);  /* end_buf */
-      tt_str_op(va_arg(ap, char *), ==, "0:01 hours");   /* remaining */
+      tt_ptr_op(strstr(va_arg(ap, char *), ":01:00"), OP_NE, NULL);  /* end_buf */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0:01 hours");   /* remaining */
       break;
     default:
       tt_abort_msg("unexpected call to logv()");  // TODO: prettyprint args
@@ -824,8 +824,8 @@ NS(test_main)(void *arg)
   expected = 0;
   actual = log_heartbeat(0);
 
-  tt_int_op(actual, ==, expected);
-  tt_int_op(CALLED(logv), ==, 2);
+  tt_int_op(actual, OP_EQ, expected);
+  tt_int_op(CALLED(logv), OP_EQ, 2);
 
   done:
     stats_n_data_bytes_packaged = 0;
@@ -893,27 +893,27 @@ NS(logv)(int severity, log_domain_mask_t domain, const char *funcname,
   switch (CALLED(logv))
   {
     case 0:
-      tt_int_op(severity, ==, LOG_NOTICE);
-      tt_int_op(domain, ==, LD_HEARTBEAT);
-      tt_ptr_op(strstr(funcname, "log_heartbeat"), !=, NULL);
-      tt_ptr_op(suffix, ==, NULL);
-      tt_str_op(format, ==,
+      tt_int_op(severity, OP_EQ, LOG_NOTICE);
+      tt_int_op(domain, OP_EQ, LD_HEARTBEAT);
+      tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL);
+      tt_ptr_op(suffix, OP_EQ, NULL);
+      tt_str_op(format, OP_EQ,
           "Heartbeat: Tor's uptime is %s, with %d circuits open. "
           "I've sent %s and received %s.%s");
-      tt_str_op(va_arg(ap, char *), ==, "0:00 hours");  /* uptime */
-      tt_int_op(va_arg(ap, int), ==, 0);  /* count_circuits() */
-      tt_str_op(va_arg(ap, char *), ==, "0 kB");  /* bw_sent */
-      tt_str_op(va_arg(ap, char *), ==, "0 kB");  /* bw_rcvd */
-      tt_str_op(va_arg(ap, char *), ==, "");  /* hibernating */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0:00 hours");  /* uptime */
+      tt_int_op(va_arg(ap, int), OP_EQ, 0);  /* count_circuits() */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB");  /* bw_sent */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB");  /* bw_rcvd */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "");  /* hibernating */
       break;
     case 1:
-      tt_int_op(severity, ==, LOG_NOTICE);
-      tt_int_op(domain, ==, LD_HEARTBEAT);
-      tt_ptr_op(strstr(funcname, "log_heartbeat"), !=, NULL);
-      tt_ptr_op(suffix, ==, NULL);
-      tt_str_op(format, ==,
+      tt_int_op(severity, OP_EQ, LOG_NOTICE);
+      tt_int_op(domain, OP_EQ, LD_HEARTBEAT);
+      tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL);
+      tt_ptr_op(suffix, OP_EQ, NULL);
+      tt_str_op(format, OP_EQ,
           "Average packaged cell fullness: %2.3f%%");
-      tt_int_op(fabs(va_arg(ap, double) - 100.0) <= DBL_EPSILON, ==, 1);
+      tt_int_op(fabs(va_arg(ap, double) - 100.0) <= DBL_EPSILON, OP_EQ, 1);
       break;
     default:
       tt_abort_msg("unexpected call to logv()");  // TODO: prettyprint args
@@ -982,8 +982,8 @@ NS(test_main)(void *arg)
   expected = 0;
   actual = log_heartbeat(0);
 
-  tt_int_op(actual, ==, expected);
-  tt_int_op(CALLED(logv), ==, 2);
+  tt_int_op(actual, OP_EQ, expected);
+  tt_int_op(CALLED(logv), OP_EQ, 2);
 
   done:
     NS_UNMOCK(tls_get_write_overhead_ratio);
@@ -1049,26 +1049,26 @@ NS(logv)(int severity, log_domain_mask_t domain,
   switch (CALLED(logv))
   {
     case 0:
-      tt_int_op(severity, ==, LOG_NOTICE);
-      tt_int_op(domain, ==, LD_HEARTBEAT);
-      tt_ptr_op(strstr(funcname, "log_heartbeat"), !=, NULL);
-      tt_ptr_op(suffix, ==, NULL);
-      tt_str_op(format, ==,
+      tt_int_op(severity, OP_EQ, LOG_NOTICE);
+      tt_int_op(domain, OP_EQ, LD_HEARTBEAT);
+      tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL);
+      tt_ptr_op(suffix, OP_EQ, NULL);
+      tt_str_op(format, OP_EQ,
           "Heartbeat: Tor's uptime is %s, with %d circuits open. "
           "I've sent %s and received %s.%s");
-      tt_str_op(va_arg(ap, char *), ==, "0:00 hours");  /* uptime */
-      tt_int_op(va_arg(ap, int), ==, 0);  /* count_circuits() */
-      tt_str_op(va_arg(ap, char *), ==, "0 kB");  /* bw_sent */
-      tt_str_op(va_arg(ap, char *), ==, "0 kB");  /* bw_rcvd */
-      tt_str_op(va_arg(ap, char *), ==, "");  /* hibernating */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0:00 hours");  /* uptime */
+      tt_int_op(va_arg(ap, int), OP_EQ, 0);  /* count_circuits() */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB");  /* bw_sent */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB");  /* bw_rcvd */
+      tt_str_op(va_arg(ap, char *), OP_EQ, "");  /* hibernating */
       break;
     case 1:
-      tt_int_op(severity, ==, LOG_NOTICE);
-      tt_int_op(domain, ==, LD_HEARTBEAT);
-      tt_ptr_op(strstr(funcname, "log_heartbeat"), !=, NULL);
-      tt_ptr_op(suffix, ==, NULL);
-      tt_str_op(format, ==, "TLS write overhead: %.f%%");
-      tt_int_op(fabs(va_arg(ap, double) - 100.0) <= DBL_EPSILON, ==, 1);
+      tt_int_op(severity, OP_EQ, LOG_NOTICE);
+      tt_int_op(domain, OP_EQ, LD_HEARTBEAT);
+      tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL);
+      tt_ptr_op(suffix, OP_EQ, NULL);
+      tt_str_op(format, OP_EQ, "TLS write overhead: %.f%%");
+      tt_int_op(fabs(va_arg(ap, double) - 100.0) <= DBL_EPSILON, OP_EQ, 1);
       break;
     default:
       tt_abort_msg("unexpected call to logv()");  // TODO: prettyprint args
diff --git a/src/test/test_util.c b/src/test/test_util.c
index 04dfe64..5211701 100644
--- a/src/test/test_util.c
+++ b/src/test/test_util.c
@@ -53,20 +53,20 @@ test_util_read_until_eof_impl(const char *fname, size_t file_len,
   crypto_rand(test_str, file_len);
 
   r = write_bytes_to_file(fifo_name, test_str, file_len, 1);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
 
   fd = open(fifo_name, O_RDONLY|O_BINARY);
-  tt_int_op(fd, >=, 0);
+  tt_int_op(fd, OP_GE, 0);
   str = read_file_to_str_until_eof(fd, read_limit, &sz);
   tt_assert(str != NULL);
 
   if (read_limit < file_len)
-    tt_int_op(sz, ==, read_limit);
+    tt_int_op(sz, OP_EQ, read_limit);
   else
-    tt_int_op(sz, ==, file_len);
+    tt_int_op(sz, OP_EQ, file_len);
 
-  tt_mem_op(test_str, ==, str, sz);
-  tt_int_op(str[sz], ==, '\0');
+  tt_mem_op(test_str, OP_EQ, str, sz);
+  tt_int_op(str[sz], OP_EQ, '\0');
 
  done:
   unlink(fifo_name);
@@ -168,17 +168,17 @@ test_util_write_chunks_to_file(void *arg)
 
   // write a known string to a file where the tempfile will be
   r = write_bytes_to_file(tempname, temp_str, temp_str_len, 1);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
 
   // call write_chunks_to_file
   r = write_chunks_to_file(fname, chunks, 1, 0);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
 
   // assert the file has been written (expected size)
   str = read_file_to_str(fname, RFTS_BIN, &st);
   tt_assert(str != NULL);
-  tt_u64_op((uint64_t)st.st_size, ==, data_str_len);
-  tt_mem_op(data_str, ==, str, data_str_len);
+  tt_u64_op((uint64_t)st.st_size, OP_EQ, data_str_len);
+  tt_mem_op(data_str, OP_EQ, str, data_str_len);
   tor_free(str);
 
   // assert that the tempfile is removed (should not leave artifacts)
@@ -187,7 +187,7 @@ test_util_write_chunks_to_file(void *arg)
 
   // Remove old testfile for second test
   r = unlink(fname);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
   tor_free(fname);
   tor_free(tempname);
 
@@ -199,24 +199,24 @@ test_util_write_chunks_to_file(void *arg)
 
   // write a known string to a file where the tempfile will be
   r = write_bytes_to_file(tempname, temp_str, temp_str_len, 1);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
 
   // call write_chunks_to_file with no_tempfile = true
   r = write_chunks_to_file(fname, chunks, 1, 1);
-  tt_int_op(r, ==, 0);
+  tt_int_op(r, OP_EQ, 0);
 
   // assert the file has been written (expected size)
   str = read_file_to_str(fname, RFTS_BIN, &st);
   tt_assert(str != NULL);
-  tt_u64_op((uint64_t)st.st_size, ==, data_str_len);
-  tt_mem_op(data_str, ==, str, data_str_len);
+  tt_u64_op((uint64_t)st.st_size, OP_EQ, data_str_len);
+  tt_mem_op(data_str, OP_EQ, 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);
-  tt_mem_op(temp_str, ==, str, temp_str_len);
+  tt_u64_op((uint64_t)st.st_size, OP_EQ, temp_str_len);
+  tt_mem_op(temp_str, OP_EQ, str, temp_str_len);
 
  done:
   unlink(fname);
@@ -229,7 +229,7 @@ test_util_write_chunks_to_file(void *arg)
   tor_free(temp_str);
 }
 
-#define _TFE(a, b, f)  tt_int_op((a).f, ==, (b).f)
+#define _TFE(a, b, f)  tt_int_op((a).f, OP_EQ, (b).f)
 /** test the minimum set of struct tm fields needed for a unique epoch value
  * this is also the set we use to test tor_timegm */
 #define TM_EQUAL(a, b)           \
@@ -261,23 +261,23 @@ test_util_time(void *arg)
   end.tv_sec = 5;
   end.tv_usec = 5000;
 
-  tt_int_op(0L,==, tv_udiff(&start, &end));
+  tt_int_op(0L,OP_EQ, tv_udiff(&start, &end));
 
   end.tv_usec = 7000;
 
-  tt_int_op(2000L,==, tv_udiff(&start, &end));
+  tt_int_op(2000L,OP_EQ, tv_udiff(&start, &end));
 
   end.tv_sec = 6;
 
-  tt_int_op(1002000L,==, tv_udiff(&start, &end));
+  tt_int_op(1002000L,OP_EQ, tv_udiff(&start, &end));
 
   end.tv_usec = 0;
 
-  tt_int_op(995000L,==, tv_udiff(&start, &end));
+  tt_int_op(995000L,OP_EQ, tv_udiff(&start, &end));
 
   end.tv_sec = 4;
 
-  tt_int_op(-1005000L,==, tv_udiff(&start, &end));
+  tt_int_op(-1005000L,OP_EQ, tv_udiff(&start, &end));
 
   /* Test tor_timegm & tor_gmtime_r */
 
@@ -299,26 +299,26 @@ test_util_time(void *arg)
   a_time.tm_min = 14;
   a_time.tm_sec = 55;
   t_res = 1062224095UL;
-  tt_int_op(t_res, ==, tor_timegm(&a_time));
+  tt_int_op(t_res, OP_EQ, tor_timegm(&a_time));
   tor_gmtime_r(&t_res, &b_time);
   TM_EQUAL(a_time, b_time);
 
   a_time.tm_year = 2004-1900; /* Try a leap year, after feb. */
   t_res = 1093846495UL;
-  tt_int_op(t_res, ==, tor_timegm(&a_time));
+  tt_int_op(t_res, OP_EQ, tor_timegm(&a_time));
   tor_gmtime_r(&t_res, &b_time);
   TM_EQUAL(a_time, b_time);
 
   a_time.tm_mon = 1;          /* Try a leap year, in feb. */
   a_time.tm_mday = 10;
   t_res = 1076393695UL;
-  tt_int_op(t_res, ==, tor_timegm(&a_time));
+  tt_int_op(t_res, OP_EQ, tor_timegm(&a_time));
   tor_gmtime_r(&t_res, &b_time);
   TM_EQUAL(a_time, b_time);
 
   a_time.tm_mon = 0;
   t_res = 1073715295UL;
-  tt_int_op(t_res, ==, tor_timegm(&a_time));
+  tt_int_op(t_res, OP_EQ, tor_timegm(&a_time));
   tor_gmtime_r(&t_res, &b_time);
   TM_EQUAL(a_time, b_time);
 
@@ -328,27 +328,27 @@ test_util_time(void *arg)
 
   /* Wrong year < 1970 */
   a_time.tm_year = 1969-1900;
-  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
   a_time.tm_year = -1-1900;
-  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
 #if SIZEOF_INT == 4 || SIZEOF_INT == 8
     a_time.tm_year = -1*(1 << 16);
-    tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+    tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
     /* one of the smallest tm_year values my 64 bit system supports:
      * t_res = -9223372036854775LL without clamping */
     a_time.tm_year = -292275055-1900;
-    tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+    tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
     a_time.tm_year = INT32_MIN;
-    tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+    tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 #endif
 
 #if SIZEOF_INT == 8
     a_time.tm_year = -1*(1 << 48);
-    tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+    tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
     /* while unlikely, the system's gmtime(_r) could return
      * a "correct" retrospective gregorian negative year value,
@@ -356,25 +356,25 @@ test_util_time(void *arg)
      * -1*(2^63)/60/60/24*2000/730485 + 1970 = -292277022657
      * 730485 is the number of days in two millenia, including leap days */
     a_time.tm_year = -292277022657-1900;
-    tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+    tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
     a_time.tm_year = INT64_MIN;
-    tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+    tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 #endif
 
   /* Wrong year >= INT32_MAX - 1900 */
 #if SIZEOF_INT == 4 || SIZEOF_INT == 8
     a_time.tm_year = INT32_MAX-1900;
-    tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+    tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
     a_time.tm_year = INT32_MAX;
-    tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+    tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 #endif
 
 #if SIZEOF_INT == 8
     /* one of the largest tm_year values my 64 bit system supports */
     a_time.tm_year = 292278994-1900;
-    tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+    tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
     /* while unlikely, the system's gmtime(_r) could return
      * a "correct" proleptic gregorian year value,
@@ -382,72 +382,72 @@ test_util_time(void *arg)
      * (2^63-1)/60/60/24*2000/730485 + 1970 = 292277026596
      * 730485 is the number of days in two millenia, including leap days */
     a_time.tm_year = 292277026596-1900;
-    tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+    tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
     a_time.tm_year = INT64_MAX-1900;
-    tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+    tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
     a_time.tm_year = INT64_MAX;
-    tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+    tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 #endif
 
   /* month */
   a_time.tm_year = 2007-1900;  /* restore valid year */
 
   a_time.tm_mon = 12;          /* Wrong month, it's 0-based */
-  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
   a_time.tm_mon = -1;          /* Wrong month */
-  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
   /* day */
   a_time.tm_mon = 6;            /* Try July */
   a_time.tm_mday = 32;          /* Wrong day */
-  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
   a_time.tm_mon = 5;            /* Try June */
   a_time.tm_mday = 31;          /* Wrong day */
-  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
   a_time.tm_year = 2008-1900;   /* Try a leap year */
   a_time.tm_mon = 1;            /* in feb. */
   a_time.tm_mday = 30;          /* Wrong day */
-  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
   a_time.tm_year = 2011-1900;   /* Try a non-leap year */
   a_time.tm_mon = 1;            /* in feb. */
   a_time.tm_mday = 29;          /* Wrong day */
-  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
   a_time.tm_mday = 0;           /* Wrong day, it's 1-based (to be different) */
-  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
   /* hour */
   a_time.tm_mday = 3;           /* restore valid month day */
 
   a_time.tm_hour = 24;          /* Wrong hour, it's 0-based */
-  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
   a_time.tm_hour = -1;          /* Wrong hour */
-  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
   /* minute */
   a_time.tm_hour = 22;          /* restore valid hour */
 
   a_time.tm_min = 60;           /* Wrong minute, it's 0-based */
-  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
   a_time.tm_min = -1;           /* Wrong minute */
-  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
   /* second */
   a_time.tm_min = 37;           /* restore valid minute */
 
   a_time.tm_sec = 61;           /* Wrong second: 0-based with leap seconds */
-  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
   a_time.tm_sec = -1;           /* Wrong second */
-  tt_int_op((time_t) -1,==, tor_timegm(&a_time));
+  tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));
 
   /* Test tor_gmtime_r out of range */
 
@@ -534,69 +534,69 @@ test_util_time(void *arg)
   /* Test {format,parse}_rfc1123_time */
 
   format_rfc1123_time(timestr, 0);
-  tt_str_op("Thu, 01 Jan 1970 00:00:00 GMT",==, timestr);
+  tt_str_op("Thu, 01 Jan 1970 00:00:00 GMT",OP_EQ, timestr);
   format_rfc1123_time(timestr, (time_t)1091580502UL);
-  tt_str_op("Wed, 04 Aug 2004 00:48:22 GMT",==, timestr);
+  tt_str_op("Wed, 04 Aug 2004 00:48:22 GMT",OP_EQ, timestr);
 
   t_res = 0;
   i = parse_rfc1123_time(timestr, &t_res);
-  tt_int_op(0,==, i);
-  tt_int_op(t_res,==, (time_t)1091580502UL);
+  tt_int_op(0,OP_EQ, i);
+  tt_int_op(t_res,OP_EQ, (time_t)1091580502UL);
   /* The timezone doesn't matter */
   t_res = 0;
-  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,==,
+  tt_int_op(0,OP_EQ, parse_rfc1123_time("Wed, 04 Aug 2004 00:48:22 ZUL", &t_res));
+  tt_int_op(t_res,OP_EQ, (time_t)1091580502UL);
+  tt_int_op(-1,OP_EQ,
             parse_rfc1123_time("Wed, zz Aug 2004 99-99x99 GMT", &t_res));
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             parse_rfc1123_time("Wed, 32 Mar 2011 00:00:00 GMT", &t_res));
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             parse_rfc1123_time("Wed, 30 Mar 2011 24:00:00 GMT", &t_res));
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             parse_rfc1123_time("Wed, 30 Mar 2011 23:60:00 GMT", &t_res));
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             parse_rfc1123_time("Wed, 30 Mar 2011 23:59:62 GMT", &t_res));
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             parse_rfc1123_time("Wed, 30 Mar 1969 23:59:59 GMT", &t_res));
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             parse_rfc1123_time("Wed, 30 Ene 2011 23:59:59 GMT", &t_res));
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             parse_rfc1123_time("Wed, 30 Mar 2011 23:59:59 GM", &t_res));
 
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             parse_rfc1123_time("Wed, 29 Feb 2011 16:00:00 GMT", &t_res));
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             parse_rfc1123_time("Wed, 30 Mar 2011 23:59:61 GMT", &t_res));
 
   /* Test parse_iso_time */
 
   t_res = 0;
   i = parse_iso_time("", &t_res);
-  tt_int_op(-1,==, i);
+  tt_int_op(-1,OP_EQ, i);
   t_res = 0;
   i = parse_iso_time("2004-08-32 00:48:22", &t_res);
-  tt_int_op(-1,==, i);
+  tt_int_op(-1,OP_EQ, i);
   t_res = 0;
   i = parse_iso_time("1969-08-03 00:48:22", &t_res);
-  tt_int_op(-1,==, i);
+  tt_int_op(-1,OP_EQ, i);
 
   t_res = 0;
   i = parse_iso_time("2004-08-04 00:48:22", &t_res);
-  tt_int_op(0,==, i);
-  tt_int_op(t_res,==, (time_t)1091580502UL);
+  tt_int_op(0,OP_EQ, i);
+  tt_int_op(t_res,OP_EQ, (time_t)1091580502UL);
   t_res = 0;
   i = parse_iso_time("2004-8-4 0:48:22", &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));
+  tt_int_op(0,OP_EQ, i);
+  tt_int_op(t_res,OP_EQ, (time_t)1091580502UL);
+  tt_int_op(-1,OP_EQ, parse_iso_time("2004-08-zz 99-99x99 GMT", &t_res));
+  tt_int_op(-1,OP_EQ, parse_iso_time("2011-03-32 00:00:00 GMT", &t_res));
+  tt_int_op(-1,OP_EQ, parse_iso_time("2011-03-30 24:00:00 GMT", &t_res));
+  tt_int_op(-1,OP_EQ, parse_iso_time("2011-03-30 23:60:00 GMT", &t_res));
+  tt_int_op(-1,OP_EQ, parse_iso_time("2011-03-30 23:59:62 GMT", &t_res));
+  tt_int_op(-1,OP_EQ, parse_iso_time("1969-03-30 23:59:59 GMT", &t_res));
+  tt_int_op(-1,OP_EQ, parse_iso_time("2011-00-30 23:59:59 GMT", &t_res));
+  tt_int_op(-1,OP_EQ, parse_iso_time("2147483647-08-29 14:00:00", &t_res));
+  tt_int_op(-1,OP_EQ, parse_iso_time("2011-03-30 23:59", &t_res));
 
   /* Test tor_gettimeofday */
 
@@ -609,14 +609,14 @@ test_util_time(void *arg)
   /* now make sure time works. */
   tor_gettimeofday(&end);
   /* We might've timewarped a little. */
-  tt_int_op(tv_udiff(&start, &end), >=, -5000);
+  tt_int_op(tv_udiff(&start, &end), OP_GE, -5000);
 
   /* Test format_iso_time */
 
   tv.tv_sec = (time_t)1326296338;
   tv.tv_usec = 3060;
   format_iso_time(timestr, (time_t)tv.tv_sec);
-  tt_str_op("2012-01-11 15:38:58",==, timestr);
+  tt_str_op("2012-01-11 15:38:58",OP_EQ, 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.
@@ -624,11 +624,11 @@ test_util_time(void *arg)
   test_streq("2012-01-11 10:38:58", timestr);
   */
   format_iso_time_nospace(timestr, (time_t)tv.tv_sec);
-  tt_str_op("2012-01-11T15:38:58",==, timestr);
-  tt_int_op(strlen(timestr),==, ISO_TIME_LEN);
+  tt_str_op("2012-01-11T15:38:58",OP_EQ, timestr);
+  tt_int_op(strlen(timestr),OP_EQ, ISO_TIME_LEN);
   format_iso_time_nospace_usec(timestr, &tv);
-  tt_str_op("2012-01-11T15:38:58.003060",==, timestr);
-  tt_int_op(strlen(timestr),==, ISO_TIME_USEC_LEN);
+  tt_str_op("2012-01-11T15:38:58.003060",OP_EQ, timestr);
+  tt_int_op(strlen(timestr),OP_EQ, ISO_TIME_USEC_LEN);
 
  done:
   ;
@@ -643,72 +643,72 @@ test_util_parse_http_time(void *arg)
 
 #define T(s) do {                               \
     format_iso_time(b, tor_timegm(&a_time));    \
-    tt_str_op(b, ==, (s));                      \
+    tt_str_op(b, OP_EQ, (s));                      \
     b[0]='\0';                                  \
   } while (0)
 
   /* Test parse_http_time */
 
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             parse_http_time("", &a_time));
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             parse_http_time("Sunday, 32 Aug 2004 00:48:22 GMT", &a_time));
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             parse_http_time("Sunday, 3 Aug 1869 00:48:22 GMT", &a_time));
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             parse_http_time("Sunday, 32-Aug-94 00:48:22 GMT", &a_time));
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             parse_http_time("Sunday, 3-Ago-04 00:48:22", &a_time));
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             parse_http_time("Sunday, August the third", &a_time));
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ,
             parse_http_time("Wednesday,,04 Aug 1994 00:48:22 GMT", &a_time));
 
-  tt_int_op(0,==,
+  tt_int_op(0,OP_EQ,
             parse_http_time("Wednesday, 04 Aug 1994 00:48:22 GMT", &a_time));
-  tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time));
+  tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  tt_int_op(0,==,
+  tt_int_op(0,OP_EQ,
             parse_http_time("Wednesday, 4 Aug 1994 0:48:22 GMT", &a_time));
-  tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time));
+  tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  tt_int_op(0,==,
+  tt_int_op(0,OP_EQ,
             parse_http_time("Miercoles, 4 Aug 1994 0:48:22 GMT", &a_time));
-  tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time));
+  tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  tt_int_op(0,==,
+  tt_int_op(0,OP_EQ,
             parse_http_time("Wednesday, 04-Aug-94 00:48:22 GMT", &a_time));
-  tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time));
+  tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  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));
+  tt_int_op(0,OP_EQ, parse_http_time("Wednesday, 4-Aug-94 0:48:22 GMT", &a_time));
+  tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  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));
+  tt_int_op(0,OP_EQ, parse_http_time("Miercoles, 4-Aug-94 0:48:22 GMT", &a_time));
+  tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  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));
+  tt_int_op(0,OP_EQ, parse_http_time("Wed Aug 04 00:48:22 1994", &a_time));
+  tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  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));
+  tt_int_op(0,OP_EQ, parse_http_time("Wed Aug 4 0:48:22 1994", &a_time));
+  tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  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));
+  tt_int_op(0,OP_EQ, parse_http_time("Mie Aug 4 0:48:22 1994", &a_time));
+  tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time));
   T("1994-08-04 00:48:22");
-  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));
+  tt_int_op(0,OP_EQ, parse_http_time("Sun, 1 Jan 2012 00:00:00 GMT", &a_time));
+  tt_int_op((time_t)1325376000UL,OP_EQ, tor_timegm(&a_time));
   T("2012-01-01 00:00:00");
-  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));
+  tt_int_op(0,OP_EQ, parse_http_time("Mon, 31 Dec 2012 00:00:00 GMT", &a_time));
+  tt_int_op((time_t)1356912000UL,OP_EQ, tor_timegm(&a_time));
   T("2012-12-31 00:00:00");
-  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));
+  tt_int_op(-1,OP_EQ, parse_http_time("2004-08-zz 99-99x99 GMT", &a_time));
+  tt_int_op(-1,OP_EQ, parse_http_time("2011-03-32 00:00:00 GMT", &a_time));
+  tt_int_op(-1,OP_EQ, parse_http_time("2011-03-30 24:00:00 GMT", &a_time));
+  tt_int_op(-1,OP_EQ, parse_http_time("2011-03-30 23:60:00 GMT", &a_time));
+  tt_int_op(-1,OP_EQ, parse_http_time("2011-03-30 23:59:62 GMT", &a_time));
+  tt_int_op(-1,OP_EQ, parse_http_time("1969-03-30 23:59:59 GMT", &a_time));
+  tt_int_op(-1,OP_EQ, parse_http_time("2011-00-30 23:59:59 GMT", &a_time));
+  tt_int_op(-1,OP_EQ, parse_http_time("2011-03-30 23:59", &a_time));
 
 #undef T
  done:
@@ -743,110 +743,110 @@ test_util_config_line(void *arg)
   str = buf;
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k");
-  tt_str_op(v,==, "v");
+  tt_str_op(k,OP_EQ, "k");
+  tt_str_op(v,OP_EQ, "v");
   tor_free(k); tor_free(v);
   tt_assert(!strcmpstart(str, "key    value with"));
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "key");
-  tt_str_op(v,==, "value with spaces");
+  tt_str_op(k,OP_EQ, "key");
+  tt_str_op(v,OP_EQ, "value with spaces");
   tor_free(k); tor_free(v);
   tt_assert(!strcmpstart(str, "keykey"));
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "keykey");
-  tt_str_op(v,==, "val");
+  tt_str_op(k,OP_EQ, "keykey");
+  tt_str_op(v,OP_EQ, "val");
   tor_free(k); tor_free(v);
   tt_assert(!strcmpstart(str, "k2\n"));
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k2");
-  tt_str_op(v,==, "");
+  tt_str_op(k,OP_EQ, "k2");
+  tt_str_op(v,OP_EQ, "");
   tor_free(k); tor_free(v);
   tt_assert(!strcmpstart(str, "k3 \n"));
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k3");
-  tt_str_op(v,==, "");
+  tt_str_op(k,OP_EQ, "k3");
+  tt_str_op(v,OP_EQ, "");
   tor_free(k); tor_free(v);
   tt_assert(!strcmpstart(str, "#comment"));
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k4");
-  tt_str_op(v,==, "");
+  tt_str_op(k,OP_EQ, "k4");
+  tt_str_op(v,OP_EQ, "");
   tor_free(k); tor_free(v);
   tt_assert(!strcmpstart(str, "k5#abc"));
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k5");
-  tt_str_op(v,==, "");
+  tt_str_op(k,OP_EQ, "k5");
+  tt_str_op(v,OP_EQ, "");
   tor_free(k); tor_free(v);
   tt_assert(!strcmpstart(str, "k6"));
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k6");
-  tt_str_op(v,==, "val");
+  tt_str_op(k,OP_EQ, "k6");
+  tt_str_op(v,OP_EQ, "val");
   tor_free(k); tor_free(v);
   tt_assert(!strcmpstart(str, "kseven"));
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "kseven");
-  tt_str_op(v,==, "a quoted \'string");
+  tt_str_op(k,OP_EQ, "kseven");
+  tt_str_op(v,OP_EQ, "a quoted \'string");
   tor_free(k); tor_free(v);
   tt_assert(!strcmpstart(str, "k8 "));
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k8");
-  tt_str_op(v,==, "a quoted\n\"str\\ing\t\x01\x01\x01\"");
+  tt_str_op(k,OP_EQ, "k8");
+  tt_str_op(v,OP_EQ, "a quoted\n\"str\\ing\t\x01\x01\x01\"");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k9");
-  tt_str_op(v,==, "a line that spans two lines.");
+  tt_str_op(k,OP_EQ, "k9");
+  tt_str_op(v,OP_EQ, "a line that spans two lines.");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k10");
-  tt_str_op(v,==, "more than one continuation");
+  tt_str_op(k,OP_EQ, "k10");
+  tt_str_op(v,OP_EQ, "more than one continuation");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k11");
-  tt_str_op(v,==, "continuation at the start");
+  tt_str_op(k,OP_EQ, "k11");
+  tt_str_op(v,OP_EQ, "continuation at the start");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k12");
-  tt_str_op(v,==, "line with a embedded");
+  tt_str_op(k,OP_EQ, "k12");
+  tt_str_op(v,OP_EQ, "line with a embedded");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k13");
-  tt_str_op(v,==, "continuation at the very start");
+  tt_str_op(k,OP_EQ, "k13");
+  tt_str_op(v,OP_EQ, "continuation at the very start");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k14");
-  tt_str_op(v,==, "a line that has a comment and" );
+  tt_str_op(k,OP_EQ, "k14");
+  tt_str_op(v,OP_EQ, "a line that has a comment and" );
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k15");
-  tt_str_op(v,==, "this should be the next new line");
+  tt_str_op(k,OP_EQ, "k15");
+  tt_str_op(v,OP_EQ, "this should be the next new line");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k16");
-  tt_str_op(v,==, "a line that has a comment and" );
+  tt_str_op(k,OP_EQ, "k16");
+  tt_str_op(v,OP_EQ, "a line that has a comment and" );
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k17");
-  tt_str_op(v,==, "this should be the next new line");
+  tt_str_op(k,OP_EQ, "k17");
+  tt_str_op(v,OP_EQ, "this should be the next new line");
   tor_free(k); tor_free(v);
 
-  tt_str_op(str,==, "");
+  tt_str_op(str,OP_EQ, "");
 
  done:
   tor_free(k);
@@ -877,30 +877,30 @@ test_util_config_line_quotes(void *arg)
   str = buf1;
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "kTrailingSpace");
-  tt_str_op(v,==, "quoted value");
+  tt_str_op(k,OP_EQ, "kTrailingSpace");
+  tt_str_op(v,OP_EQ, "quoted value");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_ptr_op(str,==, NULL);
+  tt_ptr_op(str,OP_EQ, NULL);
   tor_free(k); tor_free(v);
 
   str = buf2;
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_ptr_op(str,==, NULL);
+  tt_ptr_op(str,OP_EQ, NULL);
   tor_free(k); tor_free(v);
 
   str = buf3;
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_ptr_op(str,==, NULL);
+  tt_ptr_op(str,OP_EQ, NULL);
   tor_free(k); tor_free(v);
 
   str = buf4;
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_ptr_op(str,==, NULL);
+  tt_ptr_op(str,OP_EQ, NULL);
   tor_free(k); tor_free(v);
 
  done:
@@ -924,16 +924,16 @@ test_util_config_line_comment_character(void *arg)
   str = buf;
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k1");
-  tt_str_op(v,==, "# in quotes");
+  tt_str_op(k,OP_EQ, "k1");
+  tt_str_op(v,OP_EQ, "# in quotes");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "k2");
-  tt_str_op(v,==, "some value");
+  tt_str_op(k,OP_EQ, "k2");
+  tt_str_op(v,OP_EQ, "some value");
   tor_free(k); tor_free(v);
 
-  tt_str_op(str,==, "k3 /home/user/myTorNetwork#2\n");
+  tt_str_op(str,OP_EQ, "k3 /home/user/myTorNetwork#2\n");
 
 #if 0
   str = parse_config_line_from_str(str, &k, &v);
@@ -994,91 +994,91 @@ test_util_config_line_escaped_content(void *arg)
   str = buf1;
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "HexadecimalLower");
-  tt_str_op(v,==, "*");
+  tt_str_op(k,OP_EQ, "HexadecimalLower");
+  tt_str_op(v,OP_EQ, "*");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "HexadecimalUpper");
-  tt_str_op(v,==, "*");
+  tt_str_op(k,OP_EQ, "HexadecimalUpper");
+  tt_str_op(v,OP_EQ, "*");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "HexadecimalUpperX");
-  tt_str_op(v,==, "*");
+  tt_str_op(k,OP_EQ, "HexadecimalUpperX");
+  tt_str_op(v,OP_EQ, "*");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "Octal");
-  tt_str_op(v,==, "*");
+  tt_str_op(k,OP_EQ, "Octal");
+  tt_str_op(v,OP_EQ, "*");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "Newline");
-  tt_str_op(v,==, "\n");
+  tt_str_op(k,OP_EQ, "Newline");
+  tt_str_op(v,OP_EQ, "\n");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "Tab");
-  tt_str_op(v,==, "\t");
+  tt_str_op(k,OP_EQ, "Tab");
+  tt_str_op(v,OP_EQ, "\t");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "CarriageReturn");
-  tt_str_op(v,==, "\r");
+  tt_str_op(k,OP_EQ, "CarriageReturn");
+  tt_str_op(v,OP_EQ, "\r");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "DoubleQuote");
-  tt_str_op(v,==, "\"");
+  tt_str_op(k,OP_EQ, "DoubleQuote");
+  tt_str_op(v,OP_EQ, "\"");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "SimpleQuote");
-  tt_str_op(v,==, "'");
+  tt_str_op(k,OP_EQ, "SimpleQuote");
+  tt_str_op(v,OP_EQ, "'");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "Backslash");
-  tt_str_op(v,==, "\\");
+  tt_str_op(k,OP_EQ, "Backslash");
+  tt_str_op(v,OP_EQ, "\\");
   tor_free(k); tor_free(v);
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_str_op(k,==, "Mix");
-  tt_str_op(v,==, "This is a \"star\":\t'*'\nAnd second line");
+  tt_str_op(k,OP_EQ, "Mix");
+  tt_str_op(v,OP_EQ, "This is a \"star\":\t'*'\nAnd second line");
   tor_free(k); tor_free(v);
-  tt_str_op(str,==, "");
+  tt_str_op(str,OP_EQ, "");
 
   str = buf2;
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_ptr_op(str,==, NULL);
+  tt_ptr_op(str,OP_EQ, NULL);
   tor_free(k); tor_free(v);
 
   str = buf3;
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_ptr_op(str,==, NULL);
+  tt_ptr_op(str,OP_EQ, NULL);
   tor_free(k); tor_free(v);
 
   str = buf4;
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_ptr_op(str,==, NULL);
+  tt_ptr_op(str,OP_EQ, NULL);
   tor_free(k); tor_free(v);
 
 #if 0
   str = buf5;
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_ptr_op(str, ==, NULL);
+  tt_ptr_op(str, OP_EQ, NULL);
   tor_free(k); tor_free(v);
 #endif
 
   str = buf6;
 
   str = parse_config_line_from_str(str, &k, &v);
-  tt_ptr_op(str,==, NULL);
+  tt_ptr_op(str,OP_EQ, NULL);
   tor_free(k); tor_free(v);
 
  done:
@@ -1096,39 +1096,39 @@ test_util_expand_filename(void *arg)
   setenv("HOME", "/home/itv", 1); /* For "internal test value" */
 
   str = expand_filename("");
-  tt_str_op("",==, str);
+  tt_str_op("",OP_EQ, str);
   tor_free(str);
 
   str = expand_filename("/normal/path");
-  tt_str_op("/normal/path",==, str);
+  tt_str_op("/normal/path",OP_EQ, str);
   tor_free(str);
 
   str = expand_filename("/normal/trailing/path/");
-  tt_str_op("/normal/trailing/path/",==, str);
+  tt_str_op("/normal/trailing/path/",OP_EQ, str);
   tor_free(str);
 
   str = expand_filename("~");
-  tt_str_op("/home/itv/",==, str);
+  tt_str_op("/home/itv/",OP_EQ, str);
   tor_free(str);
 
   str = expand_filename("$HOME/nodice");
-  tt_str_op("$HOME/nodice",==, str);
+  tt_str_op("$HOME/nodice",OP_EQ, str);
   tor_free(str);
 
   str = expand_filename("~/");
-  tt_str_op("/home/itv/",==, str);
+  tt_str_op("/home/itv/",OP_EQ, str);
   tor_free(str);
 
   str = expand_filename("~/foobarqux");
-  tt_str_op("/home/itv/foobarqux",==, str);
+  tt_str_op("/home/itv/foobarqux",OP_EQ, str);
   tor_free(str);
 
   str = expand_filename("~/../../etc/passwd");
-  tt_str_op("/home/itv/../../etc/passwd",==, str);
+  tt_str_op("/home/itv/../../etc/passwd",OP_EQ, str);
   tor_free(str);
 
   str = expand_filename("~/trailing/");
-  tt_str_op("/home/itv/trailing/",==, str);
+  tt_str_op("/home/itv/trailing/",OP_EQ, 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) */
@@ -1137,15 +1137,15 @@ test_util_expand_filename(void *arg)
   setenv("HOME", "/home/itv/", 1);
 
   str = expand_filename("~");
-  tt_str_op("/home/itv/",==, str);
+  tt_str_op("/home/itv/",OP_EQ, str);
   tor_free(str);
 
   str = expand_filename("~/");
-  tt_str_op("/home/itv/",==, str);
+  tt_str_op("/home/itv/",OP_EQ, str);
   tor_free(str);
 
   str = expand_filename("~/foo");
-  tt_str_op("/home/itv/foo",==, str);
+  tt_str_op("/home/itv/foo",OP_EQ, str);
   tor_free(str);
 
   /* Try with empty $HOME */
@@ -1153,15 +1153,15 @@ test_util_expand_filename(void *arg)
   setenv("HOME", "", 1);
 
   str = expand_filename("~");
-  tt_str_op("/",==, str);
+  tt_str_op("/",OP_EQ, str);
   tor_free(str);
 
   str = expand_filename("~/");
-  tt_str_op("/",==, str);
+  tt_str_op("/",OP_EQ, str);
   tor_free(str);
 
   str = expand_filename("~/foobar");
-  tt_str_op("/foobar",==, str);
+  tt_str_op("/foobar",OP_EQ, str);
   tor_free(str);
 
   /* Try with $HOME unset */
@@ -1169,15 +1169,15 @@ test_util_expand_filename(void *arg)
   unsetenv("HOME");
 
   str = expand_filename("~");
-  tt_str_op("/",==, str);
+  tt_str_op("/",OP_EQ, str);
   tor_free(str);
 
   str = expand_filename("~/");
-  tt_str_op("/",==, str);
+  tt_str_op("/",OP_EQ, str);
   tor_free(str);
 
   str = expand_filename("~/foobar");
-  tt_str_op("/foobar",==, str);
+  tt_str_op("/foobar",OP_EQ, str);
   tor_free(str);
 
  done:
@@ -1195,30 +1195,30 @@ test_util_escape_string_socks(void *arg)
   (void)arg;
   escaped_string = tor_escape_str_for_pt_args("This is a backslash: \\",";\\");
   tt_assert(escaped_string);
-  tt_str_op(escaped_string,==, "This is a backslash: \\\\");
+  tt_str_op(escaped_string,OP_EQ, "This is a backslash: \\\\");
   tor_free(escaped_string);
 
   /** Simple semicolon escape. */
   escaped_string = tor_escape_str_for_pt_args("First rule:Do not use ;",";\\");
   tt_assert(escaped_string);
-  tt_str_op(escaped_string,==, "First rule:Do not use \\;");
+  tt_str_op(escaped_string,OP_EQ, "First rule:Do not use \\;");
   tor_free(escaped_string);
 
   /** Empty string. */
   escaped_string = tor_escape_str_for_pt_args("", ";\\");
   tt_assert(escaped_string);
-  tt_str_op(escaped_string,==, "");
+  tt_str_op(escaped_string,OP_EQ, "");
   tor_free(escaped_string);
 
   /** Escape all characters. */
   escaped_string = tor_escape_str_for_pt_args(";\\;\\", ";\\");
   tt_assert(escaped_string);
-  tt_str_op(escaped_string,==, "\\;\\\\\\;\\\\");
+  tt_str_op(escaped_string,OP_EQ, "\\;\\\\\\;\\\\");
   tor_free(escaped_string);
 
   escaped_string = tor_escape_str_for_pt_args(";", ";\\");
   tt_assert(escaped_string);
-  tt_str_op(escaped_string,==, "\\;");
+  tt_str_op(escaped_string,OP_EQ, "\\;");
   tor_free(escaped_string);
 
  done:
@@ -1254,152 +1254,152 @@ test_util_strmisc(void *arg)
 
   /* Test strl operations */
   (void)arg;
-  tt_int_op(5,==, strlcpy(buf, "Hello", 0));
-  tt_int_op(5,==, strlcpy(buf, "Hello", 10));
-  tt_str_op(buf,==, "Hello");
-  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");
+  tt_int_op(5,OP_EQ, strlcpy(buf, "Hello", 0));
+  tt_int_op(5,OP_EQ, strlcpy(buf, "Hello", 10));
+  tt_str_op(buf,OP_EQ, "Hello");
+  tt_int_op(5,OP_EQ, strlcpy(buf, "Hello", 6));
+  tt_str_op(buf,OP_EQ, "Hello");
+  tt_int_op(5,OP_EQ, strlcpy(buf, "Hello", 5));
+  tt_str_op(buf,OP_EQ, "Hell");
   strlcpy(buf, "Hello", sizeof(buf));
-  tt_int_op(10,==, strlcat(buf, "Hello", 5));
+  tt_int_op(10,OP_EQ, strlcat(buf, "Hello", 5));
 
   /* Test strstrip() */
   strlcpy(buf, "Testing 1 2 3", sizeof(buf));
   tor_strstrip(buf, ",!");
-  tt_str_op(buf,==, "Testing 1 2 3");
+  tt_str_op(buf,OP_EQ, "Testing 1 2 3");
   strlcpy(buf, "!Testing 1 2 3?", sizeof(buf));
   tor_strstrip(buf, "!? ");
-  tt_str_op(buf,==, "Testing123");
+  tt_str_op(buf,OP_EQ, "Testing123");
   strlcpy(buf, "!!!Testing 1 2 3??", sizeof(buf));
   tor_strstrip(buf, "!? ");
-  tt_str_op(buf,==, "Testing123");
+  tt_str_op(buf,OP_EQ, "Testing123");
 
   /* Test parse_long */
   /* Empty/zero input */
-  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);
+  tt_int_op(0L,OP_EQ, tor_parse_long("",10,0,100,&i,NULL));
+  tt_int_op(0,OP_EQ, i);
+  tt_int_op(0L,OP_EQ, tor_parse_long("0",10,0,100,&i,NULL));
+  tt_int_op(1,OP_EQ, i);
   /* Normal cases */
-  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);
+  tt_int_op(10L,OP_EQ, tor_parse_long("10",10,0,100,&i,NULL));
+  tt_int_op(1,OP_EQ, i);
+  tt_int_op(10L,OP_EQ, tor_parse_long("10",10,0,10,&i,NULL));
+  tt_int_op(1,OP_EQ, i);
+  tt_int_op(10L,OP_EQ, tor_parse_long("10",10,10,100,&i,NULL));
+  tt_int_op(1,OP_EQ, i);
+  tt_int_op(-50L,OP_EQ, tor_parse_long("-50",10,-100,100,&i,NULL));
+  tt_int_op(1,OP_EQ, i);
+  tt_int_op(-50L,OP_EQ, tor_parse_long("-50",10,-100,0,&i,NULL));
+  tt_int_op(1,OP_EQ, i);
+  tt_int_op(-50L,OP_EQ, tor_parse_long("-50",10,-50,0,&i,NULL));
+  tt_int_op(1,OP_EQ, i);
   /* Extra 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");
+  tt_int_op(0L,OP_EQ, tor_parse_long("10m",10,0,100,&i,NULL));
+  tt_int_op(0,OP_EQ, i);
+  tt_int_op(0L,OP_EQ, tor_parse_long("-50 plus garbage",10,-100,100,&i,NULL));
+  tt_int_op(0,OP_EQ, i);
+  tt_int_op(10L,OP_EQ, tor_parse_long("10m",10,0,100,&i,&cp));
+  tt_int_op(1,OP_EQ, i);
+  tt_str_op(cp,OP_EQ, "m");
+  tt_int_op(-50L,OP_EQ, tor_parse_long("-50 plus garbage",10,-100,100,&i,&cp));
+  tt_int_op(1,OP_EQ, i);
+  tt_str_op(cp,OP_EQ, " plus garbage");
   /* Out of bounds */
-  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);
+  tt_int_op(0L,OP_EQ,  tor_parse_long("10",10,50,100,&i,NULL));
+  tt_int_op(0,OP_EQ, i);
+  tt_int_op(0L,OP_EQ,   tor_parse_long("-50",10,0,100,&i,NULL));
+  tt_int_op(0,OP_EQ, i);
   /* Base different than 10 */
-  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);
+  tt_int_op(2L,OP_EQ,   tor_parse_long("10",2,0,100,NULL,NULL));
+  tt_int_op(0L,OP_EQ,   tor_parse_long("2",2,0,100,NULL,NULL));
+  tt_int_op(0L,OP_EQ,   tor_parse_long("10",-2,0,100,NULL,NULL));
+  tt_int_op(68284L,OP_EQ, tor_parse_long("10abc",16,0,70000,NULL,NULL));
+  tt_int_op(68284L,OP_EQ, tor_parse_long("10ABC",16,0,70000,NULL,NULL));
+  tt_int_op(0,OP_EQ, tor_parse_long("10ABC",-1,0,70000,&i,NULL));
+  tt_int_op(i,OP_EQ, 0);
 
   /* Test parse_ulong */
-  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);
+  tt_int_op(0UL,OP_EQ, tor_parse_ulong("",10,0,100,NULL,NULL));
+  tt_int_op(0UL,OP_EQ, tor_parse_ulong("0",10,0,100,NULL,NULL));
+  tt_int_op(10UL,OP_EQ, tor_parse_ulong("10",10,0,100,NULL,NULL));
+  tt_int_op(0UL,OP_EQ, tor_parse_ulong("10",10,50,100,NULL,NULL));
+  tt_int_op(10UL,OP_EQ, tor_parse_ulong("10",10,0,10,NULL,NULL));
+  tt_int_op(10UL,OP_EQ, tor_parse_ulong("10",10,10,100,NULL,NULL));
+  tt_int_op(0UL,OP_EQ, tor_parse_ulong("8",8,0,100,NULL,NULL));
+  tt_int_op(50UL,OP_EQ, tor_parse_ulong("50",10,50,100,NULL,NULL));
+  tt_int_op(0UL,OP_EQ, tor_parse_ulong("-50",10,-100,100,NULL,NULL));
+  tt_int_op(0UL,OP_EQ, tor_parse_ulong("50",-1,50,100,&i,NULL));
+  tt_int_op(0,OP_EQ, i);
 
   /* Test parse_uint64 */
   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_int_op(1,OP_EQ, i);
+  tt_str_op(cp,OP_EQ, " x");
   tt_assert(U64_LITERAL(12345678901) ==
               tor_parse_uint64("12345678901",10,0,UINT64_MAX, &i, &cp));
-  tt_int_op(1,==, i);
-  tt_str_op(cp,==, "");
+  tt_int_op(1,OP_EQ, i);
+  tt_str_op(cp,OP_EQ, "");
   tt_assert(U64_LITERAL(0) ==
               tor_parse_uint64("12345678901",10,500,INT32_MAX, &i, &cp));
-  tt_int_op(0,==, i);
+  tt_int_op(0,OP_EQ, i);
   tt_assert(U64_LITERAL(0) ==
               tor_parse_uint64("123",-1,0,INT32_MAX, &i, &cp));
-  tt_int_op(0,==, i);
+  tt_int_op(0,OP_EQ, i);
 
   {
   /* Test parse_double */
   double d = tor_parse_double("10", 0, UINT64_MAX,&i,NULL);
-  tt_int_op(1,==, i);
+  tt_int_op(1,OP_EQ, i);
   tt_assert(DBL_TO_U64(d) == 10);
   d = tor_parse_double("0", 0, UINT64_MAX,&i,NULL);
-  tt_int_op(1,==, i);
+  tt_int_op(1,OP_EQ, i);
   tt_assert(DBL_TO_U64(d) == 0);
   d = tor_parse_double(" ", 0, UINT64_MAX,&i,NULL);
-  tt_int_op(0,==, i);
+  tt_int_op(0,OP_EQ, i);
   d = tor_parse_double(".0a", 0, UINT64_MAX,&i,NULL);
-  tt_int_op(0,==, i);
+  tt_int_op(0,OP_EQ, i);
   d = tor_parse_double(".0a", 0, UINT64_MAX,&i,&cp);
-  tt_int_op(1,==, i);
+  tt_int_op(1,OP_EQ, i);
   d = tor_parse_double("-.0", 0, UINT64_MAX,&i,NULL);
-  tt_int_op(1,==, i);
+  tt_int_op(1,OP_EQ, i);
   tt_assert(DBL_TO_U64(d) == 0);
   d = tor_parse_double("-10", -100.0, 100.0,&i,NULL);
-  tt_int_op(1,==, i);
-  tt_int_op(-10.0,==, d);
+  tt_int_op(1,OP_EQ, i);
+  tt_int_op(-10.0,OP_EQ, d);
   }
 
   {
     /* Test tor_parse_* where we overflow/underflow the underlying type. */
     /* This string should overflow 64-bit ints. */
 #define TOOBIG "100000000000000000000000000"
-    tt_int_op(0L,==, tor_parse_long(TOOBIG, 10, LONG_MIN, LONG_MAX, &i, NULL));
-    tt_int_op(i,==, 0);
-    tt_int_op(0L,==,
+    tt_int_op(0L,OP_EQ, tor_parse_long(TOOBIG, 10, LONG_MIN, LONG_MAX, &i, NULL));
+    tt_int_op(i,OP_EQ, 0);
+    tt_int_op(0L,OP_EQ,
               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,
+    tt_int_op(i,OP_EQ, 0);
+    tt_int_op(0UL,OP_EQ, tor_parse_ulong(TOOBIG, 10, 0, ULONG_MAX, &i, NULL));
+    tt_int_op(i,OP_EQ, 0);
+    tt_u64_op(U64_LITERAL(0), OP_EQ, tor_parse_uint64(TOOBIG, 10,
                                              0, UINT64_MAX, &i, NULL));
-    tt_int_op(i,==, 0);
+    tt_int_op(i,OP_EQ, 0);
   }
 
   /* Test snprintf */
   /* Returning -1 when there's not enough room in the output buffer */
-  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"));
+  tt_int_op(-1,OP_EQ, tor_snprintf(buf, 0, "Foo"));
+  tt_int_op(-1,OP_EQ, tor_snprintf(buf, 2, "Foo"));
+  tt_int_op(-1,OP_EQ, tor_snprintf(buf, 3, "Foo"));
+  tt_int_op(-1,OP_NE, tor_snprintf(buf, 4, "Foo"));
   /* Always NUL-terminate the output */
   tor_snprintf(buf, 5, "abcdef");
-  tt_int_op(0,==, buf[4]);
+  tt_int_op(0,OP_EQ, buf[4]);
   tor_snprintf(buf, 10, "abcdef");
-  tt_int_op(0,==, buf[6]);
+  tt_int_op(0,OP_EQ, buf[6]);
   /* uint64 */
   tor_snprintf(buf, sizeof(buf), "x!"U64_FORMAT"!x",
                U64_PRINTF_ARG(U64_LITERAL(12345678901)));
-  tt_str_op("x!12345678901!x",==, buf);
+  tt_str_op("x!12345678901!x",OP_EQ, buf);
 
   /* Test str{,case}cmpstart */
   tt_assert(strcmpstart("abcdef", "abcdef")==0);
@@ -1450,31 +1450,31 @@ test_util_strmisc(void *arg)
 
   /* Test 'escaped' */
   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\\'\"",==,
+  tt_str_op("\"\"",OP_EQ, escaped(""));
+  tt_str_op("\"abcd\"",OP_EQ, escaped("abcd"));
+  tt_str_op("\"\\\\ \\n\\r\\t\\\"\\'\"",OP_EQ, escaped("\\ \n\r\t\"'"));
+  tt_str_op("\"unnecessary \\'backslashes\\'\"",OP_EQ,
              escaped("unnecessary \'backslashes\'"));
   /* Non-printable characters appear as octal */
-  tt_str_op("\"z\\001abc\\277d\"",==,  escaped("z\001abc\277d"));
-  tt_str_op("\"z\\336\\255 ;foo\"",==, escaped("z\xde\xad\x20;foo"));
+  tt_str_op("\"z\\001abc\\277d\"",OP_EQ,  escaped("z\001abc\277d"));
+  tt_str_op("\"z\\336\\255 ;foo\"",OP_EQ, escaped("z\xde\xad\x20;foo"));
 
   /* Test strndup and memdup */
   {
     const char *s = "abcdefghijklmnopqrstuvwxyz";
     cp_tmp = tor_strndup(s, 30);
-    tt_str_op(cp_tmp,==, s); /* same string, */
-    tt_ptr_op(cp_tmp,!=,s); /* but different pointers. */
+    tt_str_op(cp_tmp,OP_EQ, s); /* same string, */
+    tt_ptr_op(cp_tmp,OP_NE,s); /* but different pointers. */
     tor_free(cp_tmp);
 
     cp_tmp = tor_strndup(s, 5);
-    tt_str_op(cp_tmp,==, "abcde");
+    tt_str_op(cp_tmp,OP_EQ, "abcde");
     tor_free(cp_tmp);
 
     s = "a\0b\0c\0d\0e\0";
     cp_tmp = tor_memdup(s,10);
-    tt_mem_op(cp_tmp,==, s, 10); /* same ram, */
-    tt_ptr_op(cp_tmp,!=,s); /* but different pointers. */
+    tt_mem_op(cp_tmp,OP_EQ, s, 10); /* same ram, */
+    tt_ptr_op(cp_tmp,OP_NE,s); /* but different pointers. */
     tor_free(cp_tmp);
   }
 
@@ -1484,9 +1484,9 @@ test_util_strmisc(void *arg)
   cp_tmp[3] = 'D';
   tt_assert(!tor_strisnonupper(cp_tmp));
   tor_strupper(cp_tmp);
-  tt_str_op(cp_tmp,==, "ABCDEF");
+  tt_str_op(cp_tmp,OP_EQ, "ABCDEF");
   tor_strlower(cp_tmp);
-  tt_str_op(cp_tmp,==, "abcdef");
+  tt_str_op(cp_tmp,OP_EQ, "abcdef");
   tt_assert(tor_strisnonupper(cp_tmp));
   tt_assert(tor_strisprint(cp_tmp));
   cp_tmp[3] = 3;
@@ -1497,18 +1497,18 @@ test_util_strmisc(void *arg)
   {
     const char *haystack = "abcde";
     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_ptr_op(tor_memmem(haystack, 5, "cd", 2),OP_EQ, haystack + 2);
+    tt_ptr_op(tor_memmem(haystack, 5, "cde", 3),OP_EQ, haystack + 2);
     tt_assert(!tor_memmem(haystack, 4, "cde", 3));
     haystack = "ababcad";
-    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_ptr_op(tor_memmem(haystack, 7, "abc", 3),OP_EQ, haystack + 2);
+    tt_ptr_op(tor_memmem(haystack, 7, "ad", 2),OP_EQ, haystack + 5);
+    tt_ptr_op(tor_memmem(haystack, 7, "cad", 3),OP_EQ, haystack + 4);
     tt_assert(!tor_memmem(haystack, 7, "dadad", 5));
     tt_assert(!tor_memmem(haystack, 7, "abcdefghij", 10));
     /* memstr */
-    tt_ptr_op(tor_memstr(haystack, 7, "abc"),==, haystack + 2);
-    tt_ptr_op(tor_memstr(haystack, 7, "cad"),==, haystack + 4);
+    tt_ptr_op(tor_memstr(haystack, 7, "abc"),OP_EQ, haystack + 2);
+    tt_ptr_op(tor_memstr(haystack, 7, "cad"),OP_EQ, haystack + 4);
     tt_assert(!tor_memstr(haystack, 6, "cad"));
     tt_assert(!tor_memstr(haystack, 7, "cadd"));
     tt_assert(!tor_memstr(haystack, 7, "fe"));
@@ -1521,42 +1521,42 @@ test_util_strmisc(void *arg)
     size_t i;
     for (i = 0; i < sizeof(binary_data); ++i)
       binary_data[i] = i;
-    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),==,
+    tt_str_op(hex_str(binary_data, 0),OP_EQ, "");
+    tt_str_op(hex_str(binary_data, 1),OP_EQ, "00");
+    tt_str_op(hex_str(binary_data, 17),OP_EQ,
               "000102030405060708090A0B0C0D0E0F10");
-    tt_str_op(hex_str(binary_data, 32),==,
+    tt_str_op(hex_str(binary_data, 32),OP_EQ,
                "000102030405060708090A0B0C0D0E0F"
                "101112131415161718191A1B1C1D1E1F");
-    tt_str_op(hex_str(binary_data, 34),==,
+    tt_str_op(hex_str(binary_data, 34),OP_EQ,
                "000102030405060708090A0B0C0D0E0F"
                "101112131415161718191A1B1C1D1E1F");
     /* Repeat these tests for shorter strings after longer strings
        have been tried, to make sure we're correctly terminating strings */
-    tt_str_op(hex_str(binary_data, 1),==, "00");
-    tt_str_op(hex_str(binary_data, 0),==, "");
+    tt_str_op(hex_str(binary_data, 1),OP_EQ, "00");
+    tt_str_op(hex_str(binary_data, 0),OP_EQ, "");
   }
 
   /* Test strcmp_opt */
-  tt_int_op(strcmp_opt("",   "foo"), <, 0);
-  tt_int_op(strcmp_opt("",    ""),  ==, 0);
-  tt_int_op(strcmp_opt("foo", ""),   >, 0);
+  tt_int_op(strcmp_opt("",   "foo"), OP_LT, 0);
+  tt_int_op(strcmp_opt("",    ""),  OP_EQ, 0);
+  tt_int_op(strcmp_opt("foo", ""),   OP_GT, 0);
 
-  tt_int_op(strcmp_opt(NULL,  ""),    <, 0);
-  tt_int_op(strcmp_opt(NULL,  NULL), ==, 0);
-  tt_int_op(strcmp_opt("",    NULL),  >, 0);
+  tt_int_op(strcmp_opt(NULL,  ""),    OP_LT, 0);
+  tt_int_op(strcmp_opt(NULL,  NULL), OP_EQ, 0);
+  tt_int_op(strcmp_opt("",    NULL),  OP_GT, 0);
 
-  tt_int_op(strcmp_opt(NULL,  "foo"), <, 0);
-  tt_int_op(strcmp_opt("foo", NULL),  >, 0);
+  tt_int_op(strcmp_opt(NULL,  "foo"), OP_LT, 0);
+  tt_int_op(strcmp_opt("foo", NULL),  OP_GT, 0);
 
   /* Test strcmp_len */
-  tt_int_op(strcmp_len("foo", "bar", 3),   >, 0);
-  tt_int_op(strcmp_len("foo", "bar", 2),   <, 0); /* First len, then lexical */
-  tt_int_op(strcmp_len("foo2", "foo1", 4), >, 0);
-  tt_int_op(strcmp_len("foo2", "foo1", 3), <, 0); /* Really stop at len */
-  tt_int_op(strcmp_len("foo2", "foo", 3), ==, 0);   /* Really stop at len */
-  tt_int_op(strcmp_len("blah", "", 4),     >, 0);
-  tt_int_op(strcmp_len("blah", "", 0),    ==, 0);
+  tt_int_op(strcmp_len("foo", "bar", 3),   OP_GT, 0);
+  tt_int_op(strcmp_len("foo", "bar", 2),   OP_LT, 0); /* First len, then lexical */
+  tt_int_op(strcmp_len("foo2", "foo1", 4), OP_GT, 0);
+  tt_int_op(strcmp_len("foo2", "foo1", 3), OP_LT, 0); /* Really stop at len */
+  tt_int_op(strcmp_len("foo2", "foo", 3), OP_EQ, 0);   /* Really stop at len */
+  tt_int_op(strcmp_len("blah", "", 4),     OP_GT, 0);
+  tt_int_op(strcmp_len("blah", "", 0),    OP_EQ, 0);
 
  done:
   tor_free(cp_tmp);
@@ -1567,34 +1567,34 @@ test_util_pow2(void *arg)
 {
   /* Test tor_log2(). */
   (void)arg;
-  tt_int_op(tor_log2(64),==, 6);
-  tt_int_op(tor_log2(65),==, 6);
-  tt_int_op(tor_log2(63),==, 5);
-  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);
+  tt_int_op(tor_log2(64),OP_EQ, 6);
+  tt_int_op(tor_log2(65),OP_EQ, 6);
+  tt_int_op(tor_log2(63),OP_EQ, 5);
+  tt_int_op(tor_log2(0),OP_EQ, 0);/* incorrect mathematically, but as specified */
+  tt_int_op(tor_log2(1),OP_EQ, 0);
+  tt_int_op(tor_log2(2),OP_EQ, 1);
+  tt_int_op(tor_log2(3),OP_EQ, 1);
+  tt_int_op(tor_log2(4),OP_EQ, 2);
+  tt_int_op(tor_log2(5),OP_EQ, 2);
+  tt_int_op(tor_log2(U64_LITERAL(40000000000000000)),OP_EQ, 55);
+  tt_int_op(tor_log2(UINT64_MAX),OP_EQ, 63);
 
   /* Test round_to_power_of_2 */
-  tt_u64_op(round_to_power_of_2(120), ==, 128);
-  tt_u64_op(round_to_power_of_2(128), ==, 128);
-  tt_u64_op(round_to_power_of_2(130), ==, 128);
-  tt_u64_op(round_to_power_of_2(U64_LITERAL(40000000000000000)), ==,
+  tt_u64_op(round_to_power_of_2(120), OP_EQ, 128);
+  tt_u64_op(round_to_power_of_2(128), OP_EQ, 128);
+  tt_u64_op(round_to_power_of_2(130), OP_EQ, 128);
+  tt_u64_op(round_to_power_of_2(U64_LITERAL(40000000000000000)), OP_EQ,
             U64_LITERAL(1)<<55);
-  tt_u64_op(round_to_power_of_2(U64_LITERAL(0xffffffffffffffff)), ==,
+  tt_u64_op(round_to_power_of_2(U64_LITERAL(0xffffffffffffffff)), OP_EQ,
           U64_LITERAL(1)<<63);
-  tt_u64_op(round_to_power_of_2(0), ==, 1);
-  tt_u64_op(round_to_power_of_2(1), ==, 1);
-  tt_u64_op(round_to_power_of_2(2), ==, 2);
-  tt_u64_op(round_to_power_of_2(3), ==, 2);
-  tt_u64_op(round_to_power_of_2(4), ==, 4);
-  tt_u64_op(round_to_power_of_2(5), ==, 4);
-  tt_u64_op(round_to_power_of_2(6), ==, 4);
-  tt_u64_op(round_to_power_of_2(7), ==, 8);
+  tt_u64_op(round_to_power_of_2(0), OP_EQ, 1);
+  tt_u64_op(round_to_power_of_2(1), OP_EQ, 1);
+  tt_u64_op(round_to_power_of_2(2), OP_EQ, 2);
+  tt_u64_op(round_to_power_of_2(3), OP_EQ, 2);
+  tt_u64_op(round_to_power_of_2(4), OP_EQ, 4);
+  tt_u64_op(round_to_power_of_2(5), OP_EQ, 4);
+  tt_u64_op(round_to_power_of_2(6), OP_EQ, 4);
+  tt_u64_op(round_to_power_of_2(7), OP_EQ, 8);
 
  done:
   ;
@@ -1758,8 +1758,8 @@ test_util_gzip(void *arg)
     tt_assert(!tor_gzip_uncompress(&buf3, &len2, buf2, len1,
                                      GZIP_METHOD, 1, LOG_INFO));
     tt_assert(buf3);
-    tt_int_op(strlen(buf1) + 1,==, len2);
-    tt_str_op(buf1,==, buf3);
+    tt_int_op(strlen(buf1) + 1,OP_EQ, len2);
+    tt_str_op(buf1,OP_EQ, buf3);
 
     tor_free(buf2);
     tor_free(buf3);
@@ -1773,8 +1773,8 @@ test_util_gzip(void *arg)
   tt_assert(!tor_gzip_uncompress(&buf3, &len2, buf2, len1,
                                    ZLIB_METHOD, 1, LOG_INFO));
   tt_assert(buf3);
-  tt_int_op(strlen(buf1) + 1,==, len2);
-  tt_str_op(buf1,==, buf3);
+  tt_int_op(strlen(buf1) + 1,OP_EQ, len2);
+  tt_str_op(buf1,OP_EQ, buf3);
 
   /* Check whether we can uncompress concatenated, compressed strings. */
   tor_free(buf3);
@@ -1782,8 +1782,8 @@ test_util_gzip(void *arg)
   memcpy(buf2+len1, buf2, len1);
   tt_assert(!tor_gzip_uncompress(&buf3, &len2, buf2, len1*2,
                                    ZLIB_METHOD, 1, LOG_INFO));
-  tt_int_op((strlen(buf1)+1)*2,==, len2);
-  tt_mem_op(buf3,==,
+  tt_int_op((strlen(buf1)+1)*2,OP_EQ, len2);
+  tt_mem_op(buf3,OP_EQ,
              "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAAAAAAAAAAAAAAAAZ\0"
              "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAAAAAAAAAAAAAAAAZ\0",
              (strlen(buf1)+1)*2);
@@ -1823,20 +1823,20 @@ test_util_gzip(void *arg)
   len2 = 21;
   tt_assert(tor_zlib_process(state, &cp1, &len1, &ccp2, &len2, 0)
               == TOR_ZLIB_OK);
-  tt_int_op(0,==, len2); /* Make sure we compressed it all. */
+  tt_int_op(0,OP_EQ, len2); /* Make sure we compressed it all. */
   tt_assert(cp1 > buf1);
 
   len2 = 0;
   cp2 = cp1;
   tt_assert(tor_zlib_process(state, &cp1, &len1, &ccp2, &len2, 1)
               == TOR_ZLIB_DONE);
-  tt_int_op(0,==, len2);
+  tt_int_op(0,OP_EQ, 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));
-  tt_str_op(buf3,==,"ABCDEFGHIJABCDEFGHIJ"); /*Make sure it compressed right.*/
-  tt_int_op(21,==, len2);
+  tt_str_op(buf3,OP_EQ,"ABCDEFGHIJABCDEFGHIJ"); /*Make sure it compressed right.*/
+  tt_int_op(21,OP_EQ, len2);
 
  done:
   if (state)
@@ -1867,25 +1867,25 @@ test_util_mmap(void *arg)
 
   mapping = tor_mmap_file(fname1);
   tt_assert(mapping);
-  tt_int_op(mapping->size,==, strlen("Short file."));
-  tt_str_op(mapping->data,==, "Short file.");
+  tt_int_op(mapping->size,OP_EQ, strlen("Short file."));
+  tt_str_op(mapping->data,OP_EQ, "Short file.");
 #ifdef _WIN32
-  tt_int_op(0, ==, tor_munmap_file(mapping));
+  tt_int_op(0, OP_EQ, tor_munmap_file(mapping));
   mapping = NULL;
   tt_assert(unlink(fname1) == 0);
 #else
   /* make sure we can unlink. */
   tt_assert(unlink(fname1) == 0);
-  tt_str_op(mapping->data,==, "Short file.");
-  tt_int_op(0, ==, tor_munmap_file(mapping));
+  tt_str_op(mapping->data,OP_EQ, "Short file.");
+  tt_int_op(0, OP_EQ, tor_munmap_file(mapping));
   mapping = NULL;
 #endif
 
   /* Now a zero-length file. */
   write_str_to_file(fname1, "", 1);
   mapping = tor_mmap_file(fname1);
-  tt_ptr_op(mapping,==, NULL);
-  tt_int_op(ERANGE,==, errno);
+  tt_ptr_op(mapping,OP_EQ, NULL);
+  tt_int_op(ERANGE,OP_EQ, errno);
   unlink(fname1);
 
   /* Make sure that we fail to map a no-longer-existent file. */
@@ -1896,18 +1896,18 @@ test_util_mmap(void *arg)
   write_bytes_to_file(fname2, buf, buflen, 1);
   mapping = tor_mmap_file(fname2);
   tt_assert(mapping);
-  tt_int_op(mapping->size,==, buflen);
-  tt_mem_op(mapping->data,==, buf, buflen);
-  tt_int_op(0, ==, tor_munmap_file(mapping));
+  tt_int_op(mapping->size,OP_EQ, buflen);
+  tt_mem_op(mapping->data,OP_EQ, buf, buflen);
+  tt_int_op(0, OP_EQ, 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);
   tt_assert(mapping);
-  tt_int_op(mapping->size,==, 16384);
-  tt_mem_op(mapping->data,==, buf, 16384);
-  tt_int_op(0, ==, tor_munmap_file(mapping));
+  tt_int_op(mapping->size,OP_EQ, 16384);
+  tt_mem_op(mapping->data,OP_EQ, buf, 16384);
+  tt_int_op(0, OP_EQ, tor_munmap_file(mapping));
   mapping = NULL;
 
  done:
@@ -1934,9 +1934,9 @@ test_util_control_formats(void *arg)
 
   (void)arg;
   sz = read_escaped_data(inp, strlen(inp), &out);
-  tt_str_op(out,==,
+  tt_str_op(out,OP_EQ,
              ".This is a test\nof the emergency \n.system.\n\rZ.\n");
-  tt_int_op(sz,==, strlen(out));
+  tt_int_op(sz,OP_EQ, strlen(out));
 
  done:
   tor_free(out);
@@ -1968,334 +1968,334 @@ test_util_sscanf(void *arg)
 
   /* Simple tests (malformed patterns, literal matching, ...) */
   (void)arg;
-  tt_int_op(-1,==, tor_sscanf("123", "%i", &r)); /* %i is not supported */
-  tt_int_op(-1,==,
+  tt_int_op(-1,OP_EQ, tor_sscanf("123", "%i", &r)); /* %i is not supported */
+  tt_int_op(-1,OP_EQ,
             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));
+  tt_int_op(-1,OP_EQ, tor_sscanf("hello", "%s", s1)); /* %s needs a number. */
+  tt_int_op(-1,OP_EQ, 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" */
-  tt_int_op(0,==, tor_sscanf("hello world", "hello world"));
-  tt_int_op(0,==, tor_sscanf("hello world", "good bye"));
+  tt_int_op(0,OP_EQ, tor_sscanf("hello world", "hello world"));
+  tt_int_op(0,OP_EQ, tor_sscanf("hello world", "good bye"));
   /* Excess data */
-  tt_int_op(0,==,
+  tt_int_op(0,OP_EQ,
             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,==,
+  tt_int_op(0,OP_EQ, tor_sscanf(" 3 hello", "%u", &u1));
+  tt_int_op(0,OP_EQ,
             tor_sscanf(" 3 hello", "%2u", &u1)); /* not even in this case */
-  tt_int_op(1,==,
+  tt_int_op(1,OP_EQ,
             tor_sscanf("3 hello", "%u", &u1));  /* but trailing is alright */
 
   /* Numbers (ie. %u) */
-  tt_int_op(0,==,
+  tt_int_op(0,OP_EQ,
             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 */
+  tt_int_op(1,OP_EQ, tor_sscanf("12345", "%u", &u1));
+  tt_int_op(12345u,OP_EQ, u1);
+  tt_int_op(1,OP_EQ, tor_sscanf("12346 ", "%u", &u1));
+  tt_int_op(12346u,OP_EQ, u1);
+  tt_int_op(0,OP_EQ, tor_sscanf(" 12347", "%u", &u1));
+  tt_int_op(1,OP_EQ, tor_sscanf(" 12348", " %u", &u1));
+  tt_int_op(12348u,OP_EQ, u1);
+  tt_int_op(1,OP_EQ, tor_sscanf("0", "%u", &u1));
+  tt_int_op(0u,OP_EQ, u1);
+  tt_int_op(1,OP_EQ, tor_sscanf("0000", "%u", &u2));
+  tt_int_op(0u,OP_EQ, u2);
+  tt_int_op(0,OP_EQ, tor_sscanf("", "%u", &u1)); /* absent number */
+  tt_int_op(0,OP_EQ, tor_sscanf("A", "%u", &u1)); /* bogus number */
+  tt_int_op(0,OP_EQ, tor_sscanf("-1", "%u", &u1)); /* negative number */
 
   /* Numbers with size (eg. %2u) */
-  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,==,
+  tt_int_op(0,OP_EQ, tor_sscanf("-1", "%2u", &u1));
+  tt_int_op(2,OP_EQ, tor_sscanf("123456", "%2u%u", &u1, &u2));
+  tt_int_op(12u,OP_EQ, u1);
+  tt_int_op(3456u,OP_EQ, u2);
+  tt_int_op(1,OP_EQ, tor_sscanf("123456", "%8u", &u1));
+  tt_int_op(123456u,OP_EQ, u1);
+  tt_int_op(1,OP_EQ, tor_sscanf("123457  ", "%8u", &u1));
+  tt_int_op(123457u,OP_EQ, u1);
+  tt_int_op(0,OP_EQ, tor_sscanf("  123456", "%8u", &u1));
+  tt_int_op(3,OP_EQ, tor_sscanf("!12:3:456", "!%2u:%2u:%3u", &u1, &u2, &u3));
+  tt_int_op(12u,OP_EQ, u1);
+  tt_int_op(3u,OP_EQ, u2);
+  tt_int_op(456u,OP_EQ, u3);
+  tt_int_op(3,OP_EQ,
             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);
+  tt_int_op(67u,OP_EQ, u1);
+  tt_int_op(8u,OP_EQ, u2);
+  tt_int_op(99u,OP_EQ, u3);
   /* %u does not match space.*/
-  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);
+  tt_int_op(2,OP_EQ, tor_sscanf("12:3: 45", "%2u:%2u:%3u", &u1, &u2, &u3));
+  tt_int_op(12u,OP_EQ, u1);
+  tt_int_op(3u,OP_EQ, u2);
   /* %u does not match negative numbers. */
-  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);
+  tt_int_op(2,OP_EQ, tor_sscanf("67:8:-9", "%2u:%2u:%3u", &u1, &u2, &u3));
+  tt_int_op(67u,OP_EQ, u1);
+  tt_int_op(8u,OP_EQ, u2);
   /* Arbitrary amounts of 0-padding are okay */
-  tt_int_op(3,==, tor_sscanf("12:03:000000000000000099", "%2u:%2u:%u",
+  tt_int_op(3,OP_EQ, tor_sscanf("12:03:000000000000000099", "%2u:%2u:%u",
                         &u1, &u2, &u3));
-  tt_int_op(12u,==, u1);
-  tt_int_op(3u,==, u2);
-  tt_int_op(99u,==, u3);
+  tt_int_op(12u,OP_EQ, u1);
+  tt_int_op(3u,OP_EQ, u2);
+  tt_int_op(99u,OP_EQ, u3);
 
   /* Hex (ie. %x) */
-  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);
+  tt_int_op(3,OP_EQ, tor_sscanf("1234 02aBcdEf ff", "%x %x %x", &u1, &u2, &u3));
+  tt_int_op(0x1234,OP_EQ, u1);
+  tt_int_op(0x2ABCDEF,OP_EQ, u2);
+  tt_int_op(0xFF,OP_EQ, u3);
   /* Width works on %x */
-  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);
+  tt_int_op(3,OP_EQ, tor_sscanf("f00dcafe444", "%4x%4x%u", &u1, &u2, &u3));
+  tt_int_op(0xf00d,OP_EQ, u1);
+  tt_int_op(0xcafe,OP_EQ, u2);
+  tt_int_op(444,OP_EQ, u3);
 
   /* Literal '%' (ie. '%%') */
-  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);
+  tt_int_op(1,OP_EQ, tor_sscanf("99% fresh", "%3u%% fresh", &u1));
+  tt_int_op(99,OP_EQ, u1);
+  tt_int_op(0,OP_EQ, tor_sscanf("99 fresh", "%% %3u %s", &u1, s1));
+  tt_int_op(1,OP_EQ, tor_sscanf("99 fresh", "%3u%% %s", &u1, s1));
+  tt_int_op(2,OP_EQ, tor_sscanf("99 fresh", "%3u %5s %%", &u1, s1));
+  tt_int_op(99,OP_EQ, u1);
+  tt_str_op(s1,OP_EQ, "fresh");
+  tt_int_op(1,OP_EQ, tor_sscanf("% boo", "%% %3s", s1));
+  tt_str_op("boo",OP_EQ, s1);
 
   /* Strings (ie. %s) */
-  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");
+  tt_int_op(2,OP_EQ, tor_sscanf("hello", "%3s%7s", s1, s2));
+  tt_str_op(s1,OP_EQ, "hel");
+  tt_str_op(s2,OP_EQ, "lo");
+  tt_int_op(2,OP_EQ, tor_sscanf("WD40", "%2s%u", s3, &u1)); /* %s%u */
+  tt_str_op(s3,OP_EQ, "WD");
+  tt_int_op(40,OP_EQ, u1);
+  tt_int_op(2,OP_EQ, tor_sscanf("WD40", "%3s%u", s3, &u1)); /* %s%u */
+  tt_str_op(s3,OP_EQ, "WD4");
+  tt_int_op(0,OP_EQ, u1);
+  tt_int_op(2,OP_EQ, tor_sscanf("76trombones", "%6u%9s", &u1, s1)); /* %u%s */
+  tt_int_op(76,OP_EQ, u1);
+  tt_str_op(s1,OP_EQ, "trombones");
+  tt_int_op(1,OP_EQ, tor_sscanf("prettylongstring", "%999s", s1));
+  tt_str_op(s1,OP_EQ, "prettylongstring");
   /* %s doesn't eat spaces */
-  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,==,
+  tt_int_op(2,OP_EQ, tor_sscanf("hello world", "%9s %9s", s1, s2));
+  tt_str_op(s1,OP_EQ, "hello");
+  tt_str_op(s2,OP_EQ, "world");
+  tt_int_op(2,OP_EQ, tor_sscanf("bye   world?", "%9s %9s", s1, s2));
+  tt_str_op(s1,OP_EQ, "bye");
+  tt_str_op(s2,OP_EQ, "");
+  tt_int_op(3,OP_EQ,
             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,==, "");
+  tt_str_op(s1,OP_EQ, "hi");
+  tt_str_op(s2,OP_EQ, "");
+  tt_str_op(s3,OP_EQ, "");
 
-  tt_int_op(3,==, tor_sscanf("1.2.3", "%u.%u.%u%c", &u1, &u2, &u3, &ch));
-  tt_int_op(4,==,
+  tt_int_op(3,OP_EQ, tor_sscanf("1.2.3", "%u.%u.%u%c", &u1, &u2, &u3, &ch));
+  tt_int_op(4,OP_EQ,
             tor_sscanf("1.2.3 foobar", "%u.%u.%u%c", &u1, &u2, &u3, &ch));
-  tt_int_op(' ',==, ch);
+  tt_int_op(' ',OP_EQ, ch);
 
   r = tor_sscanf("12345 -67890 -1", "%d %ld %d", &int1, &lng1, &int2);
-  tt_int_op(r,==, 3);
-  tt_int_op(int1,==, 12345);
-  tt_int_op(lng1,==, -67890);
-  tt_int_op(int2,==, -1);
+  tt_int_op(r,OP_EQ, 3);
+  tt_int_op(int1,OP_EQ, 12345);
+  tt_int_op(lng1,OP_EQ, -67890);
+  tt_int_op(int2,OP_EQ, -1);
 
 #if SIZEOF_INT == 4
   /* %u */
   /* UINT32_MAX should work */
-  tt_int_op(1,==, tor_sscanf("4294967295", "%u", &u1));
-  tt_int_op(4294967295U,==, u1);
+  tt_int_op(1,OP_EQ, tor_sscanf("4294967295", "%u", &u1));
+  tt_int_op(4294967295U,OP_EQ, u1);
 
   /* But UINT32_MAX + 1 shouldn't work */
-  tt_int_op(0,==, tor_sscanf("4294967296", "%u", &u1));
+  tt_int_op(0,OP_EQ, tor_sscanf("4294967296", "%u", &u1));
   /* but parsing only 9... */
-  tt_int_op(1,==, tor_sscanf("4294967296", "%9u", &u1));
-  tt_int_op(429496729U,==, u1);
+  tt_int_op(1,OP_EQ, tor_sscanf("4294967296", "%9u", &u1));
+  tt_int_op(429496729U,OP_EQ, u1);
 
   /* %x */
   /* UINT32_MAX should work */
-  tt_int_op(1,==, tor_sscanf("FFFFFFFF", "%x", &u1));
-  tt_int_op(0xFFFFFFFF,==, u1);
+  tt_int_op(1,OP_EQ, tor_sscanf("FFFFFFFF", "%x", &u1));
+  tt_int_op(0xFFFFFFFF,OP_EQ, u1);
 
   /* But UINT32_MAX + 1 shouldn't work */
-  tt_int_op(0,==, tor_sscanf("100000000", "%x", &u1));
+  tt_int_op(0,OP_EQ, tor_sscanf("100000000", "%x", &u1));
 
   /* %d */
   /* INT32_MIN and INT32_MAX should work */
   r = tor_sscanf("-2147483648. 2147483647.", "%d. %d.", &int1, &int2);
-  tt_int_op(r,==, 2);
-  tt_int_op(int1,==, -2147483647 - 1);
-  tt_int_op(int2,==, 2147483647);
+  tt_int_op(r,OP_EQ, 2);
+  tt_int_op(int1,OP_EQ, -2147483647 - 1);
+  tt_int_op(int2,OP_EQ, 2147483647);
 
   /* But INT32_MIN - 1 and INT32_MAX + 1 shouldn't work */
   r = tor_sscanf("-2147483649.", "%d.", &int1);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 
   r = tor_sscanf("2147483648.", "%d.", &int1);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 
   /* and the first failure stops further processing */
   r = tor_sscanf("-2147483648. 2147483648.",
                  "%d. %d.", &int1, &int2);
-  tt_int_op(r,==, 1);
+  tt_int_op(r,OP_EQ, 1);
 
   r = tor_sscanf("-2147483649. 2147483647.",
                  "%d. %d.", &int1, &int2);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 
   r = tor_sscanf("2147483648. -2147483649.",
                  "%d. %d.", &int1, &int2);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 #elif SIZEOF_INT == 8
   /* %u */
   /* UINT64_MAX should work */
-  tt_int_op(1,==, tor_sscanf("18446744073709551615", "%u", &u1));
-  tt_int_op(18446744073709551615U,==, u1);
+  tt_int_op(1,OP_EQ, tor_sscanf("18446744073709551615", "%u", &u1));
+  tt_int_op(18446744073709551615U,OP_EQ, u1);
 
   /* But UINT64_MAX + 1 shouldn't work */
-  tt_int_op(0,==, tor_sscanf("18446744073709551616", "%u", &u1));
+  tt_int_op(0,OP_EQ, tor_sscanf("18446744073709551616", "%u", &u1));
   /* but parsing only 19... */
-  tt_int_op(1,==, tor_sscanf("18446744073709551616", "%19u", &u1));
-  tt_int_op(1844674407370955161U,==, u1);
+  tt_int_op(1,OP_EQ, tor_sscanf("18446744073709551616", "%19u", &u1));
+  tt_int_op(1844674407370955161U,OP_EQ, u1);
 
   /* %x */
   /* UINT64_MAX should work */
-  tt_int_op(1,==, tor_sscanf("FFFFFFFFFFFFFFFF", "%x", &u1));
-  tt_int_op(0xFFFFFFFFFFFFFFFF,==, u1);
+  tt_int_op(1,OP_EQ, tor_sscanf("FFFFFFFFFFFFFFFF", "%x", &u1));
+  tt_int_op(0xFFFFFFFFFFFFFFFF,OP_EQ, u1);
 
   /* But UINT64_MAX + 1 shouldn't work */
-  tt_int_op(0,==, tor_sscanf("10000000000000000", "%x", &u1));
+  tt_int_op(0,OP_EQ, tor_sscanf("10000000000000000", "%x", &u1));
 
   /* %d */
   /* INT64_MIN and INT64_MAX should work */
   r = tor_sscanf("-9223372036854775808. 9223372036854775807.",
                  "%d. %d.", &int1, &int2);
-  tt_int_op(r,==, 2);
-  tt_int_op(int1,==, -9223372036854775807 - 1);
-  tt_int_op(int2,==, 9223372036854775807);
+  tt_int_op(r,OP_EQ, 2);
+  tt_int_op(int1,OP_EQ, -9223372036854775807 - 1);
+  tt_int_op(int2,OP_EQ, 9223372036854775807);
 
   /* But INT64_MIN - 1 and INT64_MAX + 1 shouldn't work */
   r = tor_sscanf("-9223372036854775809.", "%d.", &int1);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 
   r = tor_sscanf("9223372036854775808.", "%d.", &int1);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 
   /* and the first failure stops further processing */
   r = tor_sscanf("-9223372036854775808. 9223372036854775808.",
                  "%d. %d.", &int1, &int2);
-  tt_int_op(r,==, 1);
+  tt_int_op(r,OP_EQ, 1);
 
   r = tor_sscanf("-9223372036854775809. 9223372036854775807.",
                  "%d. %d.", &int1, &int2);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 
   r = tor_sscanf("9223372036854775808. -9223372036854775809.",
                  "%d. %d.", &int1, &int2);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 #endif
 
 #if SIZEOF_LONG == 4
   /* %lu */
   /* UINT32_MAX should work */
-  tt_int_op(1,==, tor_sscanf("4294967295", "%lu", &ulng));
-  tt_int_op(4294967295UL,==, ulng);
+  tt_int_op(1,OP_EQ, tor_sscanf("4294967295", "%lu", &ulng));
+  tt_int_op(4294967295UL,OP_EQ, ulng);
 
   /* But UINT32_MAX + 1 shouldn't work */
-  tt_int_op(0,==, tor_sscanf("4294967296", "%lu", &ulng));
+  tt_int_op(0,OP_EQ, tor_sscanf("4294967296", "%lu", &ulng));
   /* but parsing only 9... */
-  tt_int_op(1,==, tor_sscanf("4294967296", "%9lu", &ulng));
-  tt_int_op(429496729UL,==, ulng);
+  tt_int_op(1,OP_EQ, tor_sscanf("4294967296", "%9lu", &ulng));
+  tt_int_op(429496729UL,OP_EQ, ulng);
 
   /* %lx */
   /* UINT32_MAX should work */
-  tt_int_op(1,==, tor_sscanf("FFFFFFFF", "%lx", &ulng));
-  tt_int_op(0xFFFFFFFFUL,==, ulng);
+  tt_int_op(1,OP_EQ, tor_sscanf("FFFFFFFF", "%lx", &ulng));
+  tt_int_op(0xFFFFFFFFUL,OP_EQ, ulng);
 
   /* But UINT32_MAX + 1 shouldn't work */
-  tt_int_op(0,==, tor_sscanf("100000000", "%lx", &ulng));
+  tt_int_op(0,OP_EQ, tor_sscanf("100000000", "%lx", &ulng));
 
   /* %ld */
   /* INT32_MIN and INT32_MAX should work */
   r = tor_sscanf("-2147483648. 2147483647.", "%ld. %ld.", &lng1, &lng2);
-  tt_int_op(r,==, 2);
-  tt_int_op(lng1,==, -2147483647L - 1L);
-  tt_int_op(lng2,==, 2147483647L);
+  tt_int_op(r,OP_EQ, 2);
+  tt_int_op(lng1,OP_EQ, -2147483647L - 1L);
+  tt_int_op(lng2,OP_EQ, 2147483647L);
 
   /* But INT32_MIN - 1 and INT32_MAX + 1 shouldn't work */
   r = tor_sscanf("-2147483649.", "%ld.", &lng1);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 
   r = tor_sscanf("2147483648.", "%ld.", &lng1);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 
   /* and the first failure stops further processing */
   r = tor_sscanf("-2147483648. 2147483648.",
                  "%ld. %ld.", &lng1, &lng2);
-  tt_int_op(r,==, 1);
+  tt_int_op(r,OP_EQ, 1);
 
   r = tor_sscanf("-2147483649. 2147483647.",
                  "%ld. %ld.", &lng1, &lng2);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 
   r = tor_sscanf("2147483648. -2147483649.",
                  "%ld. %ld.", &lng1, &lng2);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 #elif SIZEOF_LONG == 8
   /* %lu */
   /* UINT64_MAX should work */
-  tt_int_op(1,==, tor_sscanf("18446744073709551615", "%lu", &ulng));
-  tt_int_op(18446744073709551615UL,==, ulng);
+  tt_int_op(1,OP_EQ, tor_sscanf("18446744073709551615", "%lu", &ulng));
+  tt_int_op(18446744073709551615UL,OP_EQ, ulng);
 
   /* But UINT64_MAX + 1 shouldn't work */
-  tt_int_op(0,==, tor_sscanf("18446744073709551616", "%lu", &ulng));
+  tt_int_op(0,OP_EQ, tor_sscanf("18446744073709551616", "%lu", &ulng));
   /* but parsing only 19... */
-  tt_int_op(1,==, tor_sscanf("18446744073709551616", "%19lu", &ulng));
-  tt_int_op(1844674407370955161UL,==, ulng);
+  tt_int_op(1,OP_EQ, tor_sscanf("18446744073709551616", "%19lu", &ulng));
+  tt_int_op(1844674407370955161UL,OP_EQ, ulng);
 
   /* %lx */
   /* UINT64_MAX should work */
-  tt_int_op(1,==, tor_sscanf("FFFFFFFFFFFFFFFF", "%lx", &ulng));
-  tt_int_op(0xFFFFFFFFFFFFFFFFUL,==, ulng);
+  tt_int_op(1,OP_EQ, tor_sscanf("FFFFFFFFFFFFFFFF", "%lx", &ulng));
+  tt_int_op(0xFFFFFFFFFFFFFFFFUL,OP_EQ, ulng);
 
   /* But UINT64_MAX + 1 shouldn't work */
-  tt_int_op(0,==, tor_sscanf("10000000000000000", "%lx", &ulng));
+  tt_int_op(0,OP_EQ, tor_sscanf("10000000000000000", "%lx", &ulng));
 
   /* %ld */
   /* INT64_MIN and INT64_MAX should work */
   r = tor_sscanf("-9223372036854775808. 9223372036854775807.",
                  "%ld. %ld.", &lng1, &lng2);
-  tt_int_op(r,==, 2);
-  tt_int_op(lng1,==, -9223372036854775807L - 1L);
-  tt_int_op(lng2,==, 9223372036854775807L);
+  tt_int_op(r,OP_EQ, 2);
+  tt_int_op(lng1,OP_EQ, -9223372036854775807L - 1L);
+  tt_int_op(lng2,OP_EQ, 9223372036854775807L);
 
   /* But INT64_MIN - 1 and INT64_MAX + 1 shouldn't work */
   r = tor_sscanf("-9223372036854775809.", "%ld.", &lng1);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 
   r = tor_sscanf("9223372036854775808.", "%ld.", &lng1);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 
   /* and the first failure stops further processing */
   r = tor_sscanf("-9223372036854775808. 9223372036854775808.",
                  "%ld. %ld.", &lng1, &lng2);
-  tt_int_op(r,==, 1);
+  tt_int_op(r,OP_EQ, 1);
 
   r = tor_sscanf("-9223372036854775809. 9223372036854775807.",
                  "%ld. %ld.", &lng1, &lng2);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 
   r = tor_sscanf("9223372036854775808. -9223372036854775809.",
                  "%ld. %ld.", &lng1, &lng2);
-  tt_int_op(r,==, 0);
+  tt_int_op(r,OP_EQ, 0);
 #endif
 
   r = tor_sscanf("123.456 .000007 -900123123.2000787 00003.2",
                  "%lf %lf %lf %lf", &d1,&d2,&d3,&d4);
-  tt_int_op(r,==, 4);
+  tt_int_op(r,OP_EQ, 4);
   test_feq(d1, 123.456);
   test_feq(d2, .000007);
   test_feq(d3, -900123123.2000787);
@@ -2350,234 +2350,234 @@ test_util_format_time_interval(void *arg)
 
   /* ignore exact spelling of "second(s)"*/
   format_time_interval(dbuf, sizeof(dbuf), 0);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_, &sec, label_s);
-  tt_int_op(r,==, 2);
-  tt_ci_char_op(label_s[0],==, 's');
-  tt_int_op(sec,==, 0);
+  tt_int_op(r,OP_EQ, 2);
+  tt_ci_char_op(label_s[0],OP_EQ, 's');
+  tt_int_op(sec,OP_EQ, 0);
 
   format_time_interval(dbuf, sizeof(dbuf), 1);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_, &sec, label_s);
-  tt_int_op(r,==, 2);
-  tt_ci_char_op(label_s[0],==, 's');
-  tt_int_op(sec,==, 1);
+  tt_int_op(r,OP_EQ, 2);
+  tt_ci_char_op(label_s[0],OP_EQ, 's');
+  tt_int_op(sec,OP_EQ, 1);
 
   format_time_interval(dbuf, sizeof(dbuf), 10);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_, &sec, label_s);
-  tt_int_op(r,==, 2);
-  tt_ci_char_op(label_s[0],==, 's');
-  tt_int_op(sec,==, 10);
+  tt_int_op(r,OP_EQ, 2);
+  tt_ci_char_op(label_s[0],OP_EQ, 's');
+  tt_int_op(sec,OP_EQ, 10);
 
   format_time_interval(dbuf, sizeof(dbuf), 59);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_, &sec, label_s);
-  tt_int_op(r,==, 2);
-  tt_ci_char_op(label_s[0],==, 's');
-  tt_int_op(sec,==, 59);
+  tt_int_op(r,OP_EQ, 2);
+  tt_ci_char_op(label_s[0],OP_EQ, 's');
+  tt_int_op(sec,OP_EQ, 59);
 
   /* negative seconds are reported as their absolute value */
 
   format_time_interval(dbuf, sizeof(dbuf), -4);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_, &sec, label_s);
-  tt_int_op(r,==, 2);
-  tt_ci_char_op(label_s[0],==, 's');
-  tt_int_op(sec,==, 4);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(r,OP_EQ, 2);
+  tt_ci_char_op(label_s[0],OP_EQ, 's');
+  tt_int_op(sec,OP_EQ, 4);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
 
   format_time_interval(dbuf, sizeof(dbuf), -32);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_, &sec, label_s);
-  tt_int_op(r,==, 2);
-  tt_ci_char_op(label_s[0],==, 's');
-  tt_int_op(sec,==, 32);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(r,OP_EQ, 2);
+  tt_ci_char_op(label_s[0],OP_EQ, 's');
+  tt_int_op(sec,OP_EQ, 32);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
 
   /* minutes: 1:00, 1:01, 1:59, 2:00, 2:01, 59:59 */
 
   /* ignore trailing "0 second(s)", if present */
   format_time_interval(dbuf, sizeof(dbuf), 60);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_, &min, label_m);
-  tt_int_op(r,==, 2);
-  tt_ci_char_op(label_m[0],==, 'm');
-  tt_int_op(min,==, 1);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(r,OP_EQ, 2);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
+  tt_int_op(min,OP_EQ, 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
 
   /* ignore exact spelling of "minute(s)," and "second(s)" */
   format_time_interval(dbuf, sizeof(dbuf), 60 + 1);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_,
                  &min, label_m, &sec, label_s);
-  tt_int_op(r,==, 4);
-  tt_int_op(min,==, 1);
-  tt_ci_char_op(label_m[0],==, 'm');
-  tt_int_op(sec,==, 1);
-  tt_ci_char_op(label_s[0],==, 's');
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(r,OP_EQ, 4);
+  tt_int_op(min,OP_EQ, 1);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
+  tt_int_op(sec,OP_EQ, 1);
+  tt_ci_char_op(label_s[0],OP_EQ, 's');
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
 
   format_time_interval(dbuf, sizeof(dbuf), 60*2 - 1);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_,
                  &min, label_m, &sec, label_s);
-  tt_int_op(r,==, 4);
-  tt_int_op(min,==, 1);
-  tt_ci_char_op(label_m[0],==, 'm');
-  tt_int_op(sec,==, 59);
-  tt_ci_char_op(label_s[0],==, 's');
+  tt_int_op(r,OP_EQ, 4);
+  tt_int_op(min,OP_EQ, 1);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
+  tt_int_op(sec,OP_EQ, 59);
+  tt_ci_char_op(label_s[0],OP_EQ, 's');
 
   /* ignore trailing "0 second(s)", if present */
   format_time_interval(dbuf, sizeof(dbuf), 60*2);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_, &min, label_m);
-  tt_int_op(r,==, 2);
-  tt_int_op(min,==, 2);
-  tt_ci_char_op(label_m[0],==, 'm');
+  tt_int_op(r,OP_EQ, 2);
+  tt_int_op(min,OP_EQ, 2);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
 
   /* ignore exact spelling of "minute(s)," and "second(s)" */
   format_time_interval(dbuf, sizeof(dbuf), 60*2 + 1);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_,
                  &min, label_m, &sec, label_s);
-  tt_int_op(r,==, 4);
-  tt_int_op(min,==, 2);
-  tt_ci_char_op(label_m[0],==, 'm');
-  tt_int_op(sec,==, 1);
-  tt_ci_char_op(label_s[0],==, 's');
+  tt_int_op(r,OP_EQ, 4);
+  tt_int_op(min,OP_EQ, 2);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
+  tt_int_op(sec,OP_EQ, 1);
+  tt_ci_char_op(label_s[0],OP_EQ, 's');
 
   format_time_interval(dbuf, sizeof(dbuf), 60*60 - 1);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_,
                  &min, label_m, &sec, label_s);
-  tt_int_op(r,==, 4);
-  tt_int_op(min,==, 59);
-  tt_ci_char_op(label_m[0],==, 'm');
-  tt_int_op(sec,==, 59);
-  tt_ci_char_op(label_s[0],==, 's');
+  tt_int_op(r,OP_EQ, 4);
+  tt_int_op(min,OP_EQ, 59);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
+  tt_int_op(sec,OP_EQ, 59);
+  tt_ci_char_op(label_s[0],OP_EQ, 's');
 
   /* negative minutes are reported as their absolute value */
 
   /* ignore trailing "0 second(s)", if present */
   format_time_interval(dbuf, sizeof(dbuf), -3*60);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_, &min, label_m);
-  tt_int_op(r,==, 2);
-  tt_int_op(min,==, 3);
-  tt_ci_char_op(label_m[0],==, 'm');
+  tt_int_op(r,OP_EQ, 2);
+  tt_int_op(min,OP_EQ, 3);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
 
   /* ignore exact spelling of "minute(s)," and "second(s)" */
   format_time_interval(dbuf, sizeof(dbuf), -96);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_,
                  &min, label_m, &sec, label_s);
-  tt_int_op(r,==, 4);
-  tt_int_op(min,==, 1);
-  tt_ci_char_op(label_m[0],==, 'm');
-  tt_int_op(sec,==, 36);
-  tt_ci_char_op(label_s[0],==, 's');
+  tt_int_op(r,OP_EQ, 4);
+  tt_int_op(min,OP_EQ, 1);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
+  tt_int_op(sec,OP_EQ, 36);
+  tt_ci_char_op(label_s[0],OP_EQ, 's');
 
   format_time_interval(dbuf, sizeof(dbuf), -2815);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_,
                  &min, label_m, &sec, label_s);
-  tt_int_op(r,==, 4);
-  tt_int_op(min,==, 46);
-  tt_ci_char_op(label_m[0],==, 'm');
-  tt_int_op(sec,==, 55);
-  tt_ci_char_op(label_s[0],==, 's');
+  tt_int_op(r,OP_EQ, 4);
+  tt_int_op(min,OP_EQ, 46);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
+  tt_int_op(sec,OP_EQ, 55);
+  tt_ci_char_op(label_s[0],OP_EQ, 's');
 
   /* hours: 1:00, 1:00:01, 1:01, 23:59, 23:59:59 */
   /* always ignore trailing seconds, if present */
 
   /* ignore trailing "0 minute(s)" etc., if present */
   format_time_interval(dbuf, sizeof(dbuf), 60*60);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_, &hour, label_h);
-  tt_int_op(r,==, 2);
-  tt_int_op(hour,==, 1);
-  tt_ci_char_op(label_h[0],==, 'h');
+  tt_int_op(r,OP_EQ, 2);
+  tt_int_op(hour,OP_EQ, 1);
+  tt_ci_char_op(label_h[0],OP_EQ, 'h');
 
   format_time_interval(dbuf, sizeof(dbuf), 60*60 + 1);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_, &hour, label_h);
-  tt_int_op(r,==, 2);
-  tt_int_op(hour,==, 1);
-  tt_ci_char_op(label_h[0],==, 'h');
+  tt_int_op(r,OP_EQ, 2);
+  tt_int_op(hour,OP_EQ, 1);
+  tt_ci_char_op(label_h[0],OP_EQ, 'h');
 
   /* ignore exact spelling of "hour(s)," etc. */
   format_time_interval(dbuf, sizeof(dbuf), 60*60 + 60);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_,
                  &hour, label_h, &min, label_m);
-  tt_int_op(r,==, 4);
-  tt_int_op(hour,==, 1);
-  tt_ci_char_op(label_h[0],==, 'h');
-  tt_int_op(min,==, 1);
-  tt_ci_char_op(label_m[0],==, 'm');
+  tt_int_op(r,OP_EQ, 4);
+  tt_int_op(hour,OP_EQ, 1);
+  tt_ci_char_op(label_h[0],OP_EQ, 'h');
+  tt_int_op(min,OP_EQ, 1);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
 
   format_time_interval(dbuf, sizeof(dbuf), 24*60*60 - 60);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_,
                  &hour, label_h, &min, label_m);
-  tt_int_op(r,==, 4);
-  tt_int_op(hour,==, 23);
-  tt_ci_char_op(label_h[0],==, 'h');
-  tt_int_op(min,==, 59);
-  tt_ci_char_op(label_m[0],==, 'm');
+  tt_int_op(r,OP_EQ, 4);
+  tt_int_op(hour,OP_EQ, 23);
+  tt_ci_char_op(label_h[0],OP_EQ, 'h');
+  tt_int_op(min,OP_EQ, 59);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
 
   format_time_interval(dbuf, sizeof(dbuf), 24*60*60 - 1);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_,
                  &hour, label_h, &min, label_m);
-  tt_int_op(r,==, 4);
-  tt_int_op(hour,==, 23);
-  tt_ci_char_op(label_h[0],==, 'h');
-  tt_int_op(min,==, 59);
-  tt_ci_char_op(label_m[0],==, 'm');
+  tt_int_op(r,OP_EQ, 4);
+  tt_int_op(hour,OP_EQ, 23);
+  tt_ci_char_op(label_h[0],OP_EQ, 'h');
+  tt_int_op(min,OP_EQ, 59);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
 
   /* negative hours are reported as their absolute value */
 
   /* ignore exact spelling of "hour(s)," etc., if present */
   format_time_interval(dbuf, sizeof(dbuf), -2*60*60);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_, &hour, label_h);
-  tt_int_op(r,==, 2);
-  tt_int_op(hour,==, 2);
-  tt_ci_char_op(label_h[0],==, 'h');
+  tt_int_op(r,OP_EQ, 2);
+  tt_int_op(hour,OP_EQ, 2);
+  tt_ci_char_op(label_h[0],OP_EQ, 'h');
 
   format_time_interval(dbuf, sizeof(dbuf), -75804);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_,
                  &hour, label_h, &min, label_m);
-  tt_int_op(r,==, 4);
-  tt_int_op(hour,==, 21);
-  tt_ci_char_op(label_h[0],==, 'h');
-  tt_int_op(min,==, 3);
-  tt_ci_char_op(label_m[0],==, 'm');
+  tt_int_op(r,OP_EQ, 4);
+  tt_int_op(hour,OP_EQ, 21);
+  tt_ci_char_op(label_h[0],OP_EQ, 'h');
+  tt_int_op(min,OP_EQ, 3);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
 
   /* days: 1:00, 1:00:00:01, 1:00:01, 1:01 */
   /* always ignore trailing seconds, if present */
 
   /* ignore trailing "0 hours(s)" etc., if present */
   format_time_interval(dbuf, sizeof(dbuf), 24*60*60);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_, &day, label_d);
-  tt_int_op(r,==, 2);
-  tt_int_op(day,==, 1);
-  tt_ci_char_op(label_d[0],==, 'd');
+  tt_int_op(r,OP_EQ, 2);
+  tt_int_op(day,OP_EQ, 1);
+  tt_ci_char_op(label_d[0],OP_EQ, 'd');
 
   format_time_interval(dbuf, sizeof(dbuf), 24*60*60 + 1);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_, &day, label_d);
-  tt_int_op(r,==, 2);
-  tt_int_op(day,==, 1);
-  tt_ci_char_op(label_d[0],==, 'd');
+  tt_int_op(r,OP_EQ, 2);
+  tt_int_op(day,OP_EQ, 1);
+  tt_ci_char_op(label_d[0],OP_EQ, 'd');
 
   /* ignore exact spelling of "days(s)," etc. */
   format_time_interval(dbuf, sizeof(dbuf), 24*60*60 + 60);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_ " " TL_,
                  &day, label_d, &hour, label_h, &min, label_m);
   if (r == -1) {
@@ -2586,68 +2586,68 @@ test_util_format_time_interval(void *arg)
                    &day, label_d, &min, label_m);
   }
   tt_assert(r == 4 || r == 6);
-  tt_int_op(day,==, 1);
-  tt_ci_char_op(label_d[0],==, 'd');
+  tt_int_op(day,OP_EQ, 1);
+  tt_ci_char_op(label_d[0],OP_EQ, 'd');
   if (r == 6) {
-    tt_int_op(hour,==, 0);
-    tt_ci_char_op(label_h[0],==, 'h');
+    tt_int_op(hour,OP_EQ, 0);
+    tt_ci_char_op(label_h[0],OP_EQ, 'h');
   }
-  tt_int_op(min,==, 1);
-  tt_ci_char_op(label_m[0],==, 'm');
+  tt_int_op(min,OP_EQ, 1);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
 
   /* ignore trailing "0 minutes(s)" etc., if present */
   format_time_interval(dbuf, sizeof(dbuf), 24*60*60 + 60*60);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_,
                  &day, label_d, &hour, label_h);
-  tt_int_op(r,==, 4);
-  tt_int_op(day,==, 1);
-  tt_ci_char_op(label_d[0],==, 'd');
-  tt_int_op(hour,==, 1);
-  tt_ci_char_op(label_h[0],==, 'h');
+  tt_int_op(r,OP_EQ, 4);
+  tt_int_op(day,OP_EQ, 1);
+  tt_ci_char_op(label_d[0],OP_EQ, 'd');
+  tt_int_op(hour,OP_EQ, 1);
+  tt_ci_char_op(label_h[0],OP_EQ, 'h');
 
   /* negative days are reported as their absolute value */
 
   format_time_interval(dbuf, sizeof(dbuf), -21936184);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_ " " TL_,
                  &day, label_d, &hour, label_h, &min, label_m);
-  tt_int_op(r,==, 6);
-  tt_int_op(day,==, 253);
-  tt_ci_char_op(label_d[0],==, 'd');
-  tt_int_op(hour,==, 21);
-  tt_ci_char_op(label_h[0],==, 'h');
-  tt_int_op(min,==, 23);
-  tt_ci_char_op(label_m[0],==, 'm');
+  tt_int_op(r,OP_EQ, 6);
+  tt_int_op(day,OP_EQ, 253);
+  tt_ci_char_op(label_d[0],OP_EQ, 'd');
+  tt_int_op(hour,OP_EQ, 21);
+  tt_ci_char_op(label_h[0],OP_EQ, 'h');
+  tt_int_op(min,OP_EQ, 23);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
 
   /* periods > 1 year are reported in days (warn?) */
 
   /* ignore exact spelling of "days(s)," etc., if present */
   format_time_interval(dbuf, sizeof(dbuf), 758635154);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_ " " TL_,
                  &day, label_d, &hour, label_h, &min, label_m);
-  tt_int_op(r,==, 6);
-  tt_int_op(day,==, 8780);
-  tt_ci_char_op(label_d[0],==, 'd');
-  tt_int_op(hour,==, 11);
-  tt_ci_char_op(label_h[0],==, 'h');
-  tt_int_op(min,==, 59);
-  tt_ci_char_op(label_m[0],==, 'm');
+  tt_int_op(r,OP_EQ, 6);
+  tt_int_op(day,OP_EQ, 8780);
+  tt_ci_char_op(label_d[0],OP_EQ, 'd');
+  tt_int_op(hour,OP_EQ, 11);
+  tt_ci_char_op(label_h[0],OP_EQ, 'h');
+  tt_int_op(min,OP_EQ, 59);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
 
   /* negative periods > 1 year are reported in days (warn?) */
 
   format_time_interval(dbuf, sizeof(dbuf), -1427014922);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_ " " TL_,
                  &day, label_d, &hour, label_h, &min, label_m);
-  tt_int_op(r,==, 6);
-  tt_int_op(day,==, 16516);
-  tt_ci_char_op(label_d[0],==, 'd');
-  tt_int_op(hour,==, 9);
-  tt_ci_char_op(label_h[0],==, 'h');
-  tt_int_op(min,==, 2);
-  tt_ci_char_op(label_m[0],==, 'm');
+  tt_int_op(r,OP_EQ, 6);
+  tt_int_op(day,OP_EQ, 16516);
+  tt_ci_char_op(label_d[0],OP_EQ, 'd');
+  tt_int_op(hour,OP_EQ, 9);
+  tt_ci_char_op(label_h[0],OP_EQ, 'h');
+  tt_int_op(min,OP_EQ, 2);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
 
 #if SIZEOF_LONG == 4 || SIZEOF_LONG == 8
 
@@ -2656,32 +2656,32 @@ test_util_format_time_interval(void *arg)
 
   /* INT32_MAX */
   format_time_interval(dbuf, sizeof(dbuf), 2147483647);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_ " " TL_,
                  &day, label_d, &hour, label_h, &min, label_m);
-  tt_int_op(r,==, 6);
-  tt_int_op(day,==, 24855);
-  tt_ci_char_op(label_d[0],==, 'd');
-  tt_int_op(hour,==, 3);
-  tt_ci_char_op(label_h[0],==, 'h');
-  tt_int_op(min,==, 14);
-  tt_ci_char_op(label_m[0],==, 'm');
+  tt_int_op(r,OP_EQ, 6);
+  tt_int_op(day,OP_EQ, 24855);
+  tt_ci_char_op(label_d[0],OP_EQ, 'd');
+  tt_int_op(hour,OP_EQ, 3);
+  tt_ci_char_op(label_h[0],OP_EQ, 'h');
+  tt_int_op(min,OP_EQ, 14);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
   /* and 7 seconds - ignored */
 
   /* INT32_MIN: check that we get the absolute value of interval,
    * which doesn't actually fit in int32_t.
    * We expect INT32_MAX or INT32_MAX + 1 with 64 bit longs */
   format_time_interval(dbuf, sizeof(dbuf), -2147483647L - 1L);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_ " " TL_,
                  &day, label_d, &hour, label_h, &min, label_m);
-  tt_int_op(r,==, 6);
-  tt_int_op(day,==, 24855);
-  tt_ci_char_op(label_d[0],==, 'd');
-  tt_int_op(hour,==, 3);
-  tt_ci_char_op(label_h[0],==, 'h');
-  tt_int_op(min,==, 14);
-  tt_ci_char_op(label_m[0],==, 'm');
+  tt_int_op(r,OP_EQ, 6);
+  tt_int_op(day,OP_EQ, 24855);
+  tt_ci_char_op(label_d[0],OP_EQ, 'd');
+  tt_int_op(hour,OP_EQ, 3);
+  tt_ci_char_op(label_h[0],OP_EQ, 'h');
+  tt_int_op(min,OP_EQ, 14);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
   /* and 7 or 8 seconds - ignored */
 
 #endif
@@ -2693,16 +2693,16 @@ test_util_format_time_interval(void *arg)
 
   /* INT64_MAX */
   format_time_interval(dbuf, sizeof(dbuf), 9223372036854775807L);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_ " " TL_,
                  &day, label_d, &hour, label_h, &min, label_m);
-  tt_int_op(r,==, 6);
-  tt_int_op(day,==, 106751991167300L);
-  tt_ci_char_op(label_d[0],==, 'd');
-  tt_int_op(hour,==, 15);
-  tt_ci_char_op(label_h[0],==, 'h');
-  tt_int_op(min,==, 30);
-  tt_ci_char_op(label_m[0],==, 'm');
+  tt_int_op(r,OP_EQ, 6);
+  tt_int_op(day,OP_EQ, 106751991167300L);
+  tt_ci_char_op(label_d[0],OP_EQ, 'd');
+  tt_int_op(hour,OP_EQ, 15);
+  tt_ci_char_op(label_h[0],OP_EQ, 'h');
+  tt_int_op(min,OP_EQ, 30);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
   /* and 7 seconds - ignored */
 
   /* INT64_MIN: check that we get the absolute value of interval,
@@ -2710,16 +2710,16 @@ test_util_format_time_interval(void *arg)
    * We expect INT64_MAX */
   format_time_interval(dbuf, sizeof(dbuf),
                        -9223372036854775807L - 1L);
-  tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1);
+  tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);
   r = tor_sscanf(dbuf, TL_ " " TL_ " " TL_,
                  &day, label_d, &hour, label_h, &min, label_m);
-  tt_int_op(r,==, 6);
-  tt_int_op(day,==, 106751991167300L);
-  tt_ci_char_op(label_d[0],==, 'd');
-  tt_int_op(hour,==, 15);
-  tt_ci_char_op(label_h[0],==, 'h');
-  tt_int_op(min,==, 30);
-  tt_ci_char_op(label_m[0],==, 'm');
+  tt_int_op(r,OP_EQ, 6);
+  tt_int_op(day,OP_EQ, 106751991167300L);
+  tt_ci_char_op(label_d[0],OP_EQ, 'd');
+  tt_int_op(hour,OP_EQ, 15);
+  tt_ci_char_op(label_h[0],OP_EQ, 'h');
+  tt_int_op(min,OP_EQ, 30);
+  tt_ci_char_op(label_m[0],OP_EQ, 'm');
   /* and 7 or 8 seconds - ignored */
 
 #endif
@@ -2741,30 +2741,30 @@ test_util_path_is_relative(void *arg)
 {
   /* OS-independent tests */
   (void)arg;
-  tt_int_op(1,==, path_is_relative(""));
-  tt_int_op(1,==, path_is_relative("dir"));
-  tt_int_op(1,==, path_is_relative("dir/"));
-  tt_int_op(1,==, path_is_relative("./dir"));
-  tt_int_op(1,==, path_is_relative("../dir"));
+  tt_int_op(1,OP_EQ, path_is_relative(""));
+  tt_int_op(1,OP_EQ, path_is_relative("dir"));
+  tt_int_op(1,OP_EQ, path_is_relative("dir/"));
+  tt_int_op(1,OP_EQ, path_is_relative("./dir"));
+  tt_int_op(1,OP_EQ, 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/"));
+  tt_int_op(0,OP_EQ, path_is_relative("/"));
+  tt_int_op(0,OP_EQ, path_is_relative("/dir"));
+  tt_int_op(0,OP_EQ, 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 */
-  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"));
-
-  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"));
+  tt_int_op(1,OP_EQ, path_is_relative("dir"));
+  tt_int_op(1,OP_EQ, path_is_relative("dir\\"));
+  tt_int_op(1,OP_EQ, path_is_relative("dir\\a:"));
+  tt_int_op(1,OP_EQ, path_is_relative("dir\\a:\\"));
+  tt_int_op(1,OP_EQ, path_is_relative("http:\\dir"));
+
+  tt_int_op(0,OP_EQ, path_is_relative("\\dir"));
+  tt_int_op(0,OP_EQ, path_is_relative("a:\\dir"));
+  tt_int_op(0,OP_EQ, path_is_relative("z:\\dir"));
 #endif
 
  done:
@@ -2793,7 +2793,7 @@ test_util_mempool(void *arg)
   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_int_op(pool->item_alloc_size & 0x03,OP_EQ, 0);
   tt_assert(pool->new_chunk_capacity < 60);
 
   allocated = smartlist_new();
@@ -2857,16 +2857,16 @@ test_util_memarea(void *arg)
   tt_assert(p1+64 <= p2);
   tt_assert(p2+52 <= p3);
   /* Make sure we aligned. */
-  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_int_op(((uintptr_t)p1) % sizeof(void*),OP_EQ, 0);
+  tt_int_op(((uintptr_t)p2) % sizeof(void*),OP_EQ, 0);
+  tt_int_op(((uintptr_t)p3) % sizeof(void*),OP_EQ, 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);
-  tt_ptr_op(p1+sizeof(void*),==, p2);
+  tt_ptr_op(p1+sizeof(void*),OP_EQ, p2);
   {
     malloced_ptr = tor_malloc(64);
     tt_assert(!memarea_owns_ptr(area, malloced_ptr));
@@ -2879,7 +2879,7 @@ test_util_memarea(void *arg)
     crypto_rand((char*)malloced_ptr, 64);
     p1 = memarea_memdup(area, malloced_ptr, 64);
     tt_assert(p1 != malloced_ptr);
-    tt_mem_op(p1,==, malloced_ptr, 64);
+    tt_mem_op(p1,OP_EQ, malloced_ptr, 64);
     tor_free(malloced_ptr);
   }
 
@@ -2888,8 +2888,8 @@ test_util_memarea(void *arg)
   p2 = memarea_strdup(area, "abcd");
   tt_assert(p1);
   tt_assert(p2);
-  tt_str_op(p1,==, "");
-  tt_str_op(p2,==, "abcd");
+  tt_str_op(p1,OP_EQ, "");
+  tt_str_op(p2,OP_EQ, "abcd");
 
   /* memarea_strndup. */
   {
@@ -2898,20 +2898,20 @@ test_util_memarea(void *arg)
     size_t len = strlen(s);
     p1 = memarea_strndup(area, s, 1000);
     p2 = memarea_strndup(area, s, 10);
-    tt_str_op(p1,==, s);
+    tt_str_op(p1,OP_EQ, s);
     tt_assert(p2 >= p1 + len + 1);
-    tt_mem_op(s,==, p2, 10);
-    tt_int_op(p2[10],==, '\0');
+    tt_mem_op(s,OP_EQ, p2, 10);
+    tt_int_op(p2[10],OP_EQ, '\0');
     p3 = memarea_strndup(area, s, len);
-    tt_str_op(p3,==, s);
+    tt_str_op(p3,OP_EQ, s);
     p3 = memarea_strndup(area, s, len-1);
-    tt_mem_op(s,==, p3, len-1);
-    tt_int_op(p3[len-1],==, '\0');
+    tt_mem_op(s,OP_EQ, p3, len-1);
+    tt_int_op(p3[len-1],OP_EQ, '\0');
   }
 
   memarea_clear(area);
   p1 = memarea_alloc(area, 1);
-  tt_ptr_op(p1,==, p1_orig);
+  tt_ptr_op(p1,OP_EQ, p1_orig);
   memarea_clear(area);
 
   /* Check for running over an area's size. */
@@ -2944,22 +2944,22 @@ test_util_datadir(void *arg)
   temp_dir = get_datadir_fname(NULL);
   f = get_datadir_fname("state");
   tor_snprintf(buf, sizeof(buf), "%s"PATH_SEPARATOR"state", temp_dir);
-  tt_str_op(f,==, buf);
+  tt_str_op(f,OP_EQ, buf);
   tor_free(f);
   f = get_datadir_fname2("cache", "thingy");
   tor_snprintf(buf, sizeof(buf),
                "%s"PATH_SEPARATOR"cache"PATH_SEPARATOR"thingy", temp_dir);
-  tt_str_op(f,==, buf);
+  tt_str_op(f,OP_EQ, 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);
-  tt_str_op(f,==, buf);
+  tt_str_op(f,OP_EQ, buf);
   tor_free(f);
   f = get_datadir_fname_suffix("cache", ".foo");
   tor_snprintf(buf, sizeof(buf), "%s"PATH_SEPARATOR"cache.foo",
                temp_dir);
-  tt_str_op(f,==, buf);
+  tt_str_op(f,OP_EQ, buf);
 
  done:
   tor_free(f);
@@ -3000,43 +3000,43 @@ test_util_strtok(void *arg)
                 "%sthey.seemed;;their!.own;most.perfect;monument%s",pad2,pad2);
     /*  -- "Year's End", Richard Wilbur */
 
-    tt_str_op("Graved",==, tor_strtok_r_impl(buf, " ", &cp1));
-    tt_str_op("they",==, tor_strtok_r_impl(buf2, ".!..;!", &cp2));
+    tt_str_op("Graved",OP_EQ, tor_strtok_r_impl(buf, " ", &cp1));
+    tt_str_op("they",OP_EQ, tor_strtok_r_impl(buf2, ".!..;!", &cp2));
 #define S1() tor_strtok_r_impl(NULL, " ", &cp1)
 #define S2() tor_strtok_r_impl(NULL, ".!..;!", &cp2)
-    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());
+    tt_str_op("on",OP_EQ, S1());
+    tt_str_op("the",OP_EQ, S1());
+    tt_str_op("dark",OP_EQ, S1());
+    tt_str_op("seemed",OP_EQ, S2());
+    tt_str_op("their",OP_EQ, S2());
+    tt_str_op("own",OP_EQ, S2());
+    tt_str_op("in",OP_EQ, S1());
+    tt_str_op("gestures",OP_EQ, S1());
+    tt_str_op("of",OP_EQ, S1());
+    tt_str_op("most",OP_EQ, S2());
+    tt_str_op("perfect",OP_EQ, S2());
+    tt_str_op("descent",OP_EQ, S1());
+    tt_str_op("monument",OP_EQ, S2());
+    tt_ptr_op(NULL,OP_EQ, S1());
+    tt_ptr_op(NULL,OP_EQ, S2());
   }
 
   buf[0] = 0;
-  tt_ptr_op(NULL,==, tor_strtok_r_impl(buf, " ", &cp1));
-  tt_ptr_op(NULL,==, tor_strtok_r_impl(buf, "!", &cp1));
+  tt_ptr_op(NULL,OP_EQ, tor_strtok_r_impl(buf, " ", &cp1));
+  tt_ptr_op(NULL,OP_EQ, tor_strtok_r_impl(buf, "!", &cp1));
 
   strlcpy(buf, "Howdy!", sizeof(buf));
-  tt_str_op("Howdy",==, tor_strtok_r_impl(buf, "!", &cp1));
-  tt_ptr_op(NULL,==, tor_strtok_r_impl(NULL, "!", &cp1));
+  tt_str_op("Howdy",OP_EQ, tor_strtok_r_impl(buf, "!", &cp1));
+  tt_ptr_op(NULL,OP_EQ, tor_strtok_r_impl(NULL, "!", &cp1));
 
   strlcpy(buf, " ", sizeof(buf));
-  tt_ptr_op(NULL,==, tor_strtok_r_impl(buf, " ", &cp1));
+  tt_ptr_op(NULL,OP_EQ, tor_strtok_r_impl(buf, " ", &cp1));
   strlcpy(buf, "  ", sizeof(buf));
-  tt_ptr_op(NULL,==, tor_strtok_r_impl(buf, " ", &cp1));
+  tt_ptr_op(NULL,OP_EQ, tor_strtok_r_impl(buf, " ", &cp1));
 
   strlcpy(buf, "something  ", sizeof(buf));
-  tt_str_op("something",==, tor_strtok_r_impl(buf, " ", &cp1));
-  tt_ptr_op(NULL,==, tor_strtok_r_impl(NULL, ";", &cp1));
+  tt_str_op("something",OP_EQ, tor_strtok_r_impl(buf, " ", &cp1));
+  tt_ptr_op(NULL,OP_EQ, tor_strtok_r_impl(NULL, ";", &cp1));
  done:
   ;
 }
@@ -3056,24 +3056,24 @@ test_util_find_str_at_start_of_line(void *ptr)
 
   (void)ptr;
 
-  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,==,
+  tt_ptr_op(long_string,OP_EQ, find_str_at_start_of_line(long_string, ""));
+  tt_ptr_op(NULL,OP_EQ, find_str_at_start_of_line(short_string, "nonsense"));
+  tt_ptr_op(NULL,OP_EQ, find_str_at_start_of_line(long_string, "nonsense"));
+  tt_ptr_op(NULL,OP_EQ, find_str_at_start_of_line(long_string, "\n"));
+  tt_ptr_op(NULL,OP_EQ, find_str_at_start_of_line(long_string, "how "));
+  tt_ptr_op(NULL,OP_EQ, find_str_at_start_of_line(long_string, "kitty"));
+  tt_ptr_op(long_string,OP_EQ, find_str_at_start_of_line(long_string, "h"));
+  tt_ptr_op(long_string,OP_EQ, find_str_at_start_of_line(long_string, "how"));
+  tt_ptr_op(line2,OP_EQ, find_str_at_start_of_line(long_string, "he"));
+  tt_ptr_op(line2,OP_EQ, find_str_at_start_of_line(long_string, "hell"));
+  tt_ptr_op(line2,OP_EQ, find_str_at_start_of_line(long_string, "hello k"));
+  tt_ptr_op(line2,OP_EQ, find_str_at_start_of_line(long_string, "hello kitty\n"));
+  tt_ptr_op(line2,OP_EQ,
             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,
+  tt_ptr_op(line3,OP_EQ, find_str_at_start_of_line(long_string, "third"));
+  tt_ptr_op(line3,OP_EQ, find_str_at_start_of_line(long_string, "third line"));
+  tt_ptr_op(NULL,OP_EQ,  find_str_at_start_of_line(long_string, "third line\n"));
+  tt_ptr_op(short_line2,OP_EQ, find_str_at_start_of_line(short_string,
                                                      "second line\n"));
  done:
   ;
@@ -3084,25 +3084,25 @@ test_util_string_is_C_identifier(void *ptr)
 {
   (void)ptr;
 
-  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"));
-
-  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("ñ"));
+  tt_int_op(1,OP_EQ, string_is_C_identifier("string_is_C_identifier"));
+  tt_int_op(1,OP_EQ, string_is_C_identifier("_string_is_C_identifier"));
+  tt_int_op(1,OP_EQ, string_is_C_identifier("_"));
+  tt_int_op(1,OP_EQ, string_is_C_identifier("i"));
+  tt_int_op(1,OP_EQ, string_is_C_identifier("_____"));
+  tt_int_op(1,OP_EQ, string_is_C_identifier("__00__"));
+  tt_int_op(1,OP_EQ, string_is_C_identifier("__init__"));
+  tt_int_op(1,OP_EQ, string_is_C_identifier("_0"));
+  tt_int_op(1,OP_EQ, string_is_C_identifier("_0string_is_C_identifier"));
+  tt_int_op(1,OP_EQ, string_is_C_identifier("_0"));
+
+  tt_int_op(0,OP_EQ, string_is_C_identifier("0_string_is_C_identifier"));
+  tt_int_op(0,OP_EQ, string_is_C_identifier("0"));
+  tt_int_op(0,OP_EQ, string_is_C_identifier(""));
+  tt_int_op(0,OP_EQ, string_is_C_identifier(";"));
+  tt_int_op(0,OP_EQ, string_is_C_identifier("i;"));
+  tt_int_op(0,OP_EQ, string_is_C_identifier("_;"));
+  tt_int_op(0,OP_EQ, string_is_C_identifier("í"));
+  tt_int_op(0,OP_EQ, string_is_C_identifier("ñ"));
 
  done:
   ;
@@ -3120,29 +3120,29 @@ test_util_asprintf(void *ptr)
   /* simple string */
   r = tor_asprintf(&cp, "simple string 100%% safe");
   tt_assert(cp);
-  tt_str_op("simple string 100% safe",==, cp);
-  tt_int_op(strlen(cp),==, r);
+  tt_str_op("simple string 100% safe",OP_EQ, cp);
+  tt_int_op(strlen(cp),OP_EQ, r);
   tor_free(cp);
 
   /* empty string */
   r = tor_asprintf(&cp, "%s", "");
   tt_assert(cp);
-  tt_str_op("",==, cp);
-  tt_int_op(strlen(cp),==, r);
+  tt_str_op("",OP_EQ, cp);
+  tt_int_op(strlen(cp),OP_EQ, r);
   tor_free(cp);
 
   /* numbers (%i) */
   r = tor_asprintf(&cp, "I like numbers-%2i, %i, etc.", -1, 2);
   tt_assert(cp);
-  tt_str_op("I like numbers--1, 2, etc.",==, cp);
-  tt_int_op(strlen(cp),==, r);
+  tt_str_op("I like numbers--1, 2, etc.",OP_EQ, cp);
+  tt_int_op(strlen(cp),OP_EQ, r);
   /* don't free cp; next test uses it. */
 
   /* numbers (%d) */
   r = tor_asprintf(&cp2, "First=%d, Second=%d", 101, 202);
   tt_assert(cp2);
-  tt_int_op(strlen(cp2),==, r);
-  tt_str_op("First=101, Second=202",==, cp2);
+  tt_int_op(strlen(cp2),OP_EQ, r);
+  tt_str_op("First=101, Second=202",OP_EQ, cp2);
   tt_assert(cp != cp2);
   tor_free(cp);
   tor_free(cp2);
@@ -3150,17 +3150,17 @@ test_util_asprintf(void *ptr)
   /* Glass-box test: a string exactly 128 characters long. */
   r = tor_asprintf(&cp, "Lorem1: %sLorem2: %s", LOREMIPSUM, LOREMIPSUM);
   tt_assert(cp);
-  tt_int_op(128,==, r);
-  tt_int_op(cp[128], ==, '\0');
-  tt_str_op("Lorem1: "LOREMIPSUM"Lorem2: "LOREMIPSUM,==, cp);
+  tt_int_op(128,OP_EQ, r);
+  tt_int_op(cp[128], OP_EQ, '\0');
+  tt_str_op("Lorem1: "LOREMIPSUM"Lorem2: "LOREMIPSUM,OP_EQ, cp);
   tor_free(cp);
 
   /* String longer than 128 characters */
   r = tor_asprintf(&cp, "1: %s 2: %s 3: %s",
                    LOREMIPSUM, LOREMIPSUM, LOREMIPSUM);
   tt_assert(cp);
-  tt_int_op(strlen(cp),==, r);
-  tt_str_op("1: "LOREMIPSUM" 2: "LOREMIPSUM" 3: "LOREMIPSUM,==, cp);
+  tt_int_op(strlen(cp),OP_EQ, r);
+  tt_str_op("1: "LOREMIPSUM" 2: "LOREMIPSUM" 3: "LOREMIPSUM,OP_EQ, cp);
 
  done:
   tor_free(cp);
@@ -3181,9 +3181,9 @@ test_util_listdir(void *ptr)
   dir1   = tor_strdup(get_fname("some-directory"));
   dirname = tor_strdup(get_fname(NULL));
 
-  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));
+  tt_int_op(0,OP_EQ, write_str_to_file(fname1, "X\n", 0));
+  tt_int_op(0,OP_EQ, write_str_to_file(fname2, "Y\n", 0));
+  tt_int_op(0,OP_EQ, write_str_to_file(fname3, "Z\n", 0));
 #ifdef _WIN32
   r = mkdir(dir1);
 #else
@@ -3229,9 +3229,9 @@ test_util_parent_dir(void *ptr)
     int ok;                                     \
     cp = tor_strdup(input);                     \
     ok = get_parent_directory(cp);              \
-    tt_int_op(expect_ok, ==, ok);               \
+    tt_int_op(expect_ok, OP_EQ, ok);               \
     if (ok==0)                                  \
-      tt_str_op(output, ==, cp);                \
+      tt_str_op(output, OP_EQ, cp);                \
     tor_free(cp);                               \
   } while (0);
 
@@ -3280,32 +3280,32 @@ test_util_ftruncate(void *ptr)
   fname = get_fname("ftruncate");
 
   fd = tor_open_cloexec(fname, O_WRONLY|O_CREAT, 0600);
-  tt_int_op(fd, >=, 0);
+  tt_int_op(fd, OP_GE, 0);
 
   /* Make the file be there. */
-  tt_int_op(strlen(message), ==, write_all(fd, message, strlen(message), 0));
-  tt_int_op((int)tor_fd_getpos(fd), ==, strlen(message));
-  tt_int_op(0, ==, fstat(fd, &st));
-  tt_int_op((int)st.st_size, ==, strlen(message));
+  tt_int_op(strlen(message), OP_EQ, write_all(fd, message, strlen(message), 0));
+  tt_int_op((int)tor_fd_getpos(fd), OP_EQ, strlen(message));
+  tt_int_op(0, OP_EQ, fstat(fd, &st));
+  tt_int_op((int)st.st_size, OP_EQ, strlen(message));
 
   /* Truncate and see if it got truncated */
-  tt_int_op(0, ==, tor_ftruncate(fd));
-  tt_int_op((int)tor_fd_getpos(fd), ==, 0);
-  tt_int_op(0, ==, fstat(fd, &st));
-  tt_int_op((int)st.st_size, ==, 0);
+  tt_int_op(0, OP_EQ, tor_ftruncate(fd));
+  tt_int_op((int)tor_fd_getpos(fd), OP_EQ, 0);
+  tt_int_op(0, OP_EQ, fstat(fd, &st));
+  tt_int_op((int)st.st_size, OP_EQ, 0);
 
   /* Replace, and see if it got replaced */
-  tt_int_op(strlen(message2), ==,
+  tt_int_op(strlen(message2), OP_EQ,
             write_all(fd, message2, strlen(message2), 0));
-  tt_int_op((int)tor_fd_getpos(fd), ==, strlen(message2));
-  tt_int_op(0, ==, fstat(fd, &st));
-  tt_int_op((int)st.st_size, ==, strlen(message2));
+  tt_int_op((int)tor_fd_getpos(fd), OP_EQ, strlen(message2));
+  tt_int_op(0, OP_EQ, fstat(fd, &st));
+  tt_int_op((int)st.st_size, OP_EQ, strlen(message2));
 
   close(fd);
   fd = -1;
 
   buf = read_file_to_str(fname, 0, NULL);
-  tt_str_op(message2, ==, buf);
+  tt_str_op(message2, OP_EQ, buf);
 
  done:
   if (fd >= 0)
@@ -3344,53 +3344,53 @@ test_util_exit_status(void *ptr)
   (void)ptr;
 
   clear_hex_errno(hex_errno);
-  tt_str_op("",==, hex_errno);
+  tt_str_op("",OP_EQ, hex_errno);
 
   clear_hex_errno(hex_errno);
   n = format_helper_exit_status(0, 0, hex_errno);
-  tt_str_op("0/0\n",==, hex_errno);
-  tt_int_op(n,==, strlen(hex_errno));
+  tt_str_op("0/0\n",OP_EQ, hex_errno);
+  tt_int_op(n,OP_EQ, strlen(hex_errno));
 
 #if SIZEOF_INT == 4
 
   clear_hex_errno(hex_errno);
   n = format_helper_exit_status(0, 0x7FFFFFFF, hex_errno);
-  tt_str_op("0/7FFFFFFF\n",==, hex_errno);
-  tt_int_op(n,==, strlen(hex_errno));
+  tt_str_op("0/7FFFFFFF\n",OP_EQ, hex_errno);
+  tt_int_op(n,OP_EQ, strlen(hex_errno));
 
   clear_hex_errno(hex_errno);
   n = format_helper_exit_status(0xFF, -0x80000000, hex_errno);
-  tt_str_op("FF/-80000000\n",==, hex_errno);
-  tt_int_op(n,==, strlen(hex_errno));
-  tt_int_op(n,==, HEX_ERRNO_SIZE);
+  tt_str_op("FF/-80000000\n",OP_EQ, hex_errno);
+  tt_int_op(n,OP_EQ, strlen(hex_errno));
+  tt_int_op(n,OP_EQ, HEX_ERRNO_SIZE);
 
 #elif SIZEOF_INT == 8
 
   clear_hex_errno(hex_errno);
   n = format_helper_exit_status(0, 0x7FFFFFFFFFFFFFFF, hex_errno);
-  tt_str_op("0/7FFFFFFFFFFFFFFF\n",==, hex_errno);
-  tt_int_op(n,==, strlen(hex_errno));
+  tt_str_op("0/7FFFFFFFFFFFFFFF\n",OP_EQ, hex_errno);
+  tt_int_op(n,OP_EQ, strlen(hex_errno));
 
   clear_hex_errno(hex_errno);
   n = format_helper_exit_status(0xFF, -0x8000000000000000, hex_errno);
-  tt_str_op("FF/-8000000000000000\n",==, hex_errno);
-  tt_int_op(n,==, strlen(hex_errno));
-  tt_int_op(n,==, HEX_ERRNO_SIZE);
+  tt_str_op("FF/-8000000000000000\n",OP_EQ, hex_errno);
+  tt_int_op(n,OP_EQ, strlen(hex_errno));
+  tt_int_op(n,OP_EQ, HEX_ERRNO_SIZE);
 
 #endif
 
   clear_hex_errno(hex_errno);
   n = format_helper_exit_status(0x7F, 0, hex_errno);
-  tt_str_op("7F/0\n",==, hex_errno);
-  tt_int_op(n,==, strlen(hex_errno));
+  tt_str_op("7F/0\n",OP_EQ, hex_errno);
+  tt_int_op(n,OP_EQ, strlen(hex_errno));
 
   clear_hex_errno(hex_errno);
   n = format_helper_exit_status(0x08, -0x242, hex_errno);
-  tt_str_op("8/-242\n",==, hex_errno);
-  tt_int_op(n,==, strlen(hex_errno));
+  tt_str_op("8/-242\n",OP_EQ, hex_errno);
+  tt_int_op(n,OP_EQ, strlen(hex_errno));
 
   clear_hex_errno(hex_errno);
-  tt_str_op("",==, hex_errno);
+  tt_str_op("",OP_EQ, hex_errno);
 
  done:
   ;
@@ -3417,83 +3417,83 @@ test_util_fgets_eagain(void *ptr)
 
   /* Set up a pipe to test on */
   retval = pipe(test_pipe);
-  tt_int_op(retval, ==, 0);
+  tt_int_op(retval, OP_EQ, 0);
 
   /* Set up the read-end to be non-blocking */
   retval = fcntl(test_pipe[0], F_SETFL, O_NONBLOCK);
-  tt_int_op(retval, ==, 0);
+  tt_int_op(retval, OP_EQ, 0);
 
   /* Open it as a stdio stream */
   test_stream = fdopen(test_pipe[0], "r");
-  tt_ptr_op(test_stream, !=, NULL);
+  tt_ptr_op(test_stream, OP_NE, NULL);
 
   /* Send in a partial line */
   retlen = write(test_pipe[1], "A", 1);
-  tt_int_op(retlen, ==, 1);
+  tt_int_op(retlen, OP_EQ, 1);
   retptr = fgets(buf, sizeof(buf), test_stream);
-  tt_int_op(errno, ==, EAGAIN);
-  tt_ptr_op(retptr, ==, buf);
-  tt_str_op(buf, ==, "A");
+  tt_int_op(errno, OP_EQ, EAGAIN);
+  tt_ptr_op(retptr, OP_EQ, buf);
+  tt_str_op(buf, OP_EQ, "A");
   errno = 0;
 
   /* Send in the rest */
   retlen = write(test_pipe[1], "B\n", 2);
-  tt_int_op(retlen, ==, 2);
+  tt_int_op(retlen, OP_EQ, 2);
   retptr = fgets(buf, sizeof(buf), test_stream);
-  tt_int_op(errno, ==, 0);
-  tt_ptr_op(retptr, ==, buf);
-  tt_str_op(buf, ==, "B\n");
+  tt_int_op(errno, OP_EQ, 0);
+  tt_ptr_op(retptr, OP_EQ, buf);
+  tt_str_op(buf, OP_EQ, "B\n");
   errno = 0;
 
   /* Send in a full line */
   retlen = write(test_pipe[1], "CD\n", 3);
-  tt_int_op(retlen, ==, 3);
+  tt_int_op(retlen, OP_EQ, 3);
   retptr = fgets(buf, sizeof(buf), test_stream);
-  tt_int_op(errno, ==, 0);
-  tt_ptr_op(retptr, ==, buf);
-  tt_str_op(buf, ==, "CD\n");
+  tt_int_op(errno, OP_EQ, 0);
+  tt_ptr_op(retptr, OP_EQ, buf);
+  tt_str_op(buf, OP_EQ, "CD\n");
   errno = 0;
 
   /* Send in a partial line */
   retlen = write(test_pipe[1], "E", 1);
-  tt_int_op(retlen, ==, 1);
+  tt_int_op(retlen, OP_EQ, 1);
   retptr = fgets(buf, sizeof(buf), test_stream);
-  tt_int_op(errno, ==, EAGAIN);
-  tt_ptr_op(retptr, ==, buf);
-  tt_str_op(buf, ==, "E");
+  tt_int_op(errno, OP_EQ, EAGAIN);
+  tt_ptr_op(retptr, OP_EQ, buf);
+  tt_str_op(buf, OP_EQ, "E");
   errno = 0;
 
   /* Send in the rest */
   retlen = write(test_pipe[1], "F\n", 2);
-  tt_int_op(retlen, ==, 2);
+  tt_int_op(retlen, OP_EQ, 2);
   retptr = fgets(buf, sizeof(buf), test_stream);
-  tt_int_op(errno, ==, 0);
-  tt_ptr_op(retptr, ==, buf);
-  tt_str_op(buf, ==, "F\n");
+  tt_int_op(errno, OP_EQ, 0);
+  tt_ptr_op(retptr, OP_EQ, buf);
+  tt_str_op(buf, OP_EQ, "F\n");
   errno = 0;
 
   /* Send in a full line and close */
   retlen = write(test_pipe[1], "GH", 2);
-  tt_int_op(retlen, ==, 2);
+  tt_int_op(retlen, OP_EQ, 2);
   retval = close(test_pipe[1]);
-  tt_int_op(retval, ==, 0);
+  tt_int_op(retval, OP_EQ, 0);
   test_pipe[1] = -1;
   retptr = fgets(buf, sizeof(buf), test_stream);
-  tt_int_op(errno, ==, 0);
-  tt_ptr_op(retptr, ==, buf);
-  tt_str_op(buf, ==, "GH");
+  tt_int_op(errno, OP_EQ, 0);
+  tt_ptr_op(retptr, OP_EQ, buf);
+  tt_str_op(buf, OP_EQ, "GH");
   errno = 0;
 
   /* Check for EOF */
   retptr = fgets(buf, sizeof(buf), test_stream);
-  tt_int_op(errno, ==, 0);
-  tt_ptr_op(retptr, ==, NULL);
+  tt_int_op(errno, OP_EQ, 0);
+  tt_ptr_op(retptr, OP_EQ, NULL);
   retval = feof(test_stream);
-  tt_int_op(retval, !=, 0);
+  tt_int_op(retval, OP_NE, 0);
   errno = 0;
 
   /* Check that buf is unchanged according to C99 and C11 */
-  tt_str_op(buf, ==, "GH");
+  tt_str_op(buf, OP_EQ, "GH");
 
  done:
   if (test_stream != NULL)
@@ -3568,7 +3568,7 @@ run_util_spawn_background(const char *argv[], const char *expected_out,
    * but we still need to handle PROCESS_STATUS_RUNNING_OR_NOTRUNNING */
   tt_assert(MATCH_PROCESS_STATUS(expected_status, status));
   if (status == PROCESS_STATUS_ERROR) {
-    tt_ptr_op(process_handle, ==, NULL);
+    tt_ptr_op(process_handle, OP_EQ, NULL);
     return;
   }
 
@@ -3611,20 +3611,20 @@ run_util_spawn_background(const char *argv[], const char *expected_out,
                                          sizeof(stdout_buf) - 1);
   tt_assert(pos >= 0);
   stdout_buf[pos] = '\0';
-  tt_int_op(strlen(expected_out),==, pos);
-  tt_str_op(expected_out,==, stdout_buf);
+  tt_int_op(strlen(expected_out),OP_EQ, pos);
+  tt_str_op(expected_out,OP_EQ, stdout_buf);
 
   notify_pending_waitpid_callbacks();
 
   /* Check it terminated correctly */
   retval = tor_get_exit_code(process_handle, 1, &exit_code);
-  tt_int_op(PROCESS_EXIT_EXITED,==, retval);
-  tt_int_op(expected_exit,==, exit_code);
+  tt_int_op(PROCESS_EXIT_EXITED,OP_EQ, retval);
+  tt_int_op(expected_exit,OP_EQ, exit_code);
   // TODO: Make test-child exit with something other than 0
 
 #ifndef _WIN32
   notify_pending_waitpid_callbacks();
-  tt_ptr_op(process_handle->waitpid_cb, ==, NULL);
+  tt_ptr_op(process_handle->waitpid_cb, OP_EQ, NULL);
 #endif
 
   /* Check stderr */
@@ -3632,8 +3632,8 @@ run_util_spawn_background(const char *argv[], const char *expected_out,
                                          sizeof(stderr_buf) - 1);
   tt_assert(pos >= 0);
   stderr_buf[pos] = '\0';
-  tt_str_op(expected_err,==, stderr_buf);
-  tt_int_op(strlen(expected_err),==, pos);
+  tt_str_op(expected_err,OP_EQ, stderr_buf);
+  tt_int_op(strlen(expected_err),OP_EQ, pos);
 
   notify_pending_waitpid_callbacks();
 
@@ -3722,9 +3722,9 @@ test_util_spawn_background_partial_read_impl(int exit_early)
 #else
   status = tor_spawn_background(argv[0], argv, NULL, &process_handle);
 #endif
-  tt_int_op(expected_status,==, status);
+  tt_int_op(expected_status,OP_EQ, status);
   tt_assert(process_handle);
-  tt_int_op(expected_status,==, process_handle->status);
+  tt_int_op(expected_status,OP_EQ, process_handle->status);
 
   /* Check stdout */
   for (expected_out_ctr = 0; expected_out[expected_out_ctr] != NULL;) {
@@ -3745,8 +3745,8 @@ test_util_spawn_background_partial_read_impl(int exit_early)
 
     tt_assert(pos > 0);
     stdout_buf[pos] = '\0';
-    tt_str_op(expected_out[expected_out_ctr],==, stdout_buf);
-    tt_int_op(strlen(expected_out[expected_out_ctr]),==, pos);
+    tt_str_op(expected_out[expected_out_ctr],OP_EQ, stdout_buf);
+    tt_int_op(strlen(expected_out[expected_out_ctr]),OP_EQ, pos);
     expected_out_ctr++;
   }
 
@@ -3761,14 +3761,14 @@ 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);
-  tt_int_op(0,==, pos);
+  tt_int_op(0,OP_EQ, 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);
-    tt_int_op(0,==, pos);
+    tt_int_op(0,OP_EQ, pos);
     tt_assert(eof);
   }
   /* Otherwise, we got the EOF on the last read */
@@ -3776,8 +3776,8 @@ test_util_spawn_background_partial_read_impl(int exit_early)
 
   /* Check it terminated correctly */
   retval = tor_get_exit_code(process_handle, 1, &exit_code);
-  tt_int_op(PROCESS_EXIT_EXITED,==, retval);
-  tt_int_op(expected_exit,==, exit_code);
+  tt_int_op(PROCESS_EXIT_EXITED,OP_EQ, retval);
+  tt_int_op(expected_exit,OP_EQ, exit_code);
 
   // TODO: Make test-child exit with something other than 0
 
@@ -3786,8 +3786,8 @@ test_util_spawn_background_partial_read_impl(int exit_early)
                                          sizeof(stderr_buf) - 1);
   tt_assert(pos >= 0);
   stderr_buf[pos] = '\0';
-  tt_str_op(expected_err,==, stderr_buf);
-  tt_int_op(strlen(expected_err),==, pos);
+  tt_str_op(expected_err,OP_EQ, stderr_buf);
+  tt_int_op(strlen(expected_err),OP_EQ, pos);
 
  done:
   tor_process_handle_destroy(process_handle, 1);
@@ -3825,8 +3825,8 @@ test_util_spawn_background_waitpid_notify(void *arg)
   status = tor_spawn_background(argv[0], argv, NULL, &process_handle);
 #endif
 
-  tt_int_op(status, ==, PROCESS_STATUS_RUNNING);
-  tt_ptr_op(process_handle, !=, NULL);
+  tt_int_op(status, OP_EQ, PROCESS_STATUS_RUNNING);
+  tt_ptr_op(process_handle, OP_NE, NULL);
 
   /* We're not going to look at the stdout/stderr output this time. Instead,
    * we're testing whether notify_pending_waitpid_calbacks() can report the
@@ -3835,14 +3835,14 @@ test_util_spawn_background_waitpid_notify(void *arg)
 
 #ifndef _WIN32
   ms_timer = 30*1000;
-  tt_ptr_op(process_handle->waitpid_cb, !=, NULL);
+  tt_ptr_op(process_handle->waitpid_cb, OP_NE, NULL);
   while (process_handle->waitpid_cb && ms_timer > 0) {
     tor_sleep_msec(100);
     ms_timer -= 100;
     notify_pending_waitpid_callbacks();
   }
-  tt_int_op(ms_timer, >, 0);
-  tt_ptr_op(process_handle->waitpid_cb, ==, NULL);
+  tt_int_op(ms_timer, OP_GT, 0);
+  tt_ptr_op(process_handle->waitpid_cb, OP_EQ, NULL);
 #endif
 
   ms_timer = 30*1000;
@@ -3851,9 +3851,9 @@ test_util_spawn_background_waitpid_notify(void *arg)
     tor_sleep_msec(100);
     ms_timer -= 100;
   }
-  tt_int_op(ms_timer, >, 0);
+  tt_int_op(ms_timer, OP_GT, 0);
 
-  tt_int_op(retval, ==, PROCESS_EXIT_EXITED);
+  tt_int_op(retval, OP_EQ, PROCESS_EXIT_EXITED);
 
  done:
   tor_process_handle_destroy(process_handle, 1);
@@ -3899,15 +3899,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));
-    tt_int_op(len,!=, 0);
-    tt_int_op(len,==, strlen(buf));
-    tt_str_op(buf,==, test_data[i].str);
+    tt_int_op(len,OP_NE, 0);
+    tt_int_op(len,OP_EQ, strlen(buf));
+    tt_str_op(buf,OP_EQ, test_data[i].str);
   }
 
-  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));
+  tt_int_op(4,OP_EQ, format_hex_number_sigsafe(0xffff, buf, 5));
+  tt_str_op(buf,OP_EQ, "FFFF");
+  tt_int_op(0,OP_EQ, format_hex_number_sigsafe(0xffff, buf, 4));
+  tt_int_op(0,OP_EQ, format_hex_number_sigsafe(0, buf, 1));
 
  done:
   return;
@@ -3943,21 +3943,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));
-    tt_int_op(len,!=, 0);
-    tt_int_op(len,==, strlen(buf));
-    tt_str_op(buf,==, test_data[i].str);
+    tt_int_op(len,OP_NE, 0);
+    tt_int_op(len,OP_EQ, strlen(buf));
+    tt_str_op(buf,OP_EQ, test_data[i].str);
 
     len = format_dec_number_sigsafe(test_data[i].x, buf,
                                     (int)(strlen(test_data[i].str) + 1));
-    tt_int_op(len,==, strlen(buf));
-    tt_str_op(buf,==, test_data[i].str);
+    tt_int_op(len,OP_EQ, strlen(buf));
+    tt_str_op(buf,OP_EQ, test_data[i].str);
   }
 
-  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));
+  tt_int_op(4,OP_EQ, format_dec_number_sigsafe(7331, buf, 5));
+  tt_str_op(buf,OP_EQ, "7331");
+  tt_int_op(0,OP_EQ, format_dec_number_sigsafe(7331, buf, 4));
+  tt_int_op(1,OP_EQ, format_dec_number_sigsafe(0, buf, 2));
+  tt_int_op(0,OP_EQ, format_dec_number_sigsafe(0, buf, 1));
 
  done:
   return;
@@ -4006,7 +4006,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]);
-    tt_str_op(cmdlines[i],==, joined_argv);
+    tt_str_op(cmdlines[i],OP_EQ, joined_argv);
     tor_free(joined_argv);
   }
 
@@ -4061,17 +4061,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 */
-      tt_int_op(MAX_SPLIT_LINE_COUNT, >, j);
+      tt_int_op(MAX_SPLIT_LINE_COUNT, OP_GT, j);
       /* Check that there actually should be a line here */
       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 */
-      tt_str_op(line,==, tests[i].split_line[j]);
+      tt_str_op(line,OP_EQ, tests[i].split_line[j]);
       j++;
     } SMARTLIST_FOREACH_END(line);
     /* Check that we didn't miss some lines */
-    tt_ptr_op(NULL,==, tests[i].split_line[j]);
+    tt_ptr_op(NULL,OP_EQ, tests[i].split_line[j]);
     tor_free(orig_line);
     smartlist_free(sl);
     sl = NULL;
@@ -4107,7 +4107,7 @@ test_util_di_ops(void *arg)
   for (i = 0; examples[i].a; ++i) {
     size_t len = strlen(examples[i].a);
     int eq1, eq2, neq1, neq2, cmp1, cmp2;
-    tt_int_op(len,==, strlen(examples[i].b));
+    tt_int_op(len,OP_EQ, 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);
@@ -4125,11 +4125,11 @@ test_util_di_ops(void *arg)
       TT_DIE(("Assertion failed."));
 
     /* Check for consistency of everything else with cmp1 */
-    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);
+    tt_int_op(eq1,OP_EQ, eq2);
+    tt_int_op(neq1,OP_EQ, neq2);
+    tt_int_op(cmp1,OP_EQ, -cmp2);
+    tt_int_op(eq1,OP_EQ, cmp1 == 0);
+    tt_int_op(neq1,OP_EQ, !eq1);
   }
 
   {
@@ -4144,22 +4144,22 @@ test_util_di_ops(void *arg)
       for (i = 0; i < 256; i++) {
         ii = (uint8_t)i;
         zz = (uint8_t)z;
-        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);
+        tt_int_op(tor_memeq(&zz, &ii, 1),OP_EQ, zz == ii);
+        tt_int_op(tor_memcmp(&zz, &ii, 1) > 0 ? GT : EQ,OP_EQ, zz > ii ? GT : EQ);
+        tt_int_op(tor_memcmp(&ii, &zz, 1) < 0 ? LT : EQ,OP_EQ, ii < zz ? LT : EQ);
       }
     }
   }
 
-  tt_int_op(1, ==, safe_mem_is_zero("", 0));
-  tt_int_op(1, ==, safe_mem_is_zero("", 1));
-  tt_int_op(0, ==, safe_mem_is_zero("a", 1));
-  tt_int_op(0, ==, safe_mem_is_zero("a", 2));
-  tt_int_op(0, ==, safe_mem_is_zero("\0a", 2));
-  tt_int_op(1, ==, safe_mem_is_zero("\0\0a", 2));
-  tt_int_op(1, ==, safe_mem_is_zero("\0\0\0\0\0\0\0\0", 8));
-  tt_int_op(1, ==, safe_mem_is_zero("\0\0\0\0\0\0\0\0a", 8));
-  tt_int_op(0, ==, safe_mem_is_zero("\0\0\0\0\0\0\0\0a", 9));
+  tt_int_op(1, OP_EQ, safe_mem_is_zero("", 0));
+  tt_int_op(1, OP_EQ, safe_mem_is_zero("", 1));
+  tt_int_op(0, OP_EQ, safe_mem_is_zero("a", 1));
+  tt_int_op(0, OP_EQ, safe_mem_is_zero("a", 2));
+  tt_int_op(0, OP_EQ, safe_mem_is_zero("\0a", 2));
+  tt_int_op(1, OP_EQ, safe_mem_is_zero("\0\0a", 2));
+  tt_int_op(1, OP_EQ, safe_mem_is_zero("\0\0\0\0\0\0\0\0", 8));
+  tt_int_op(1, OP_EQ, safe_mem_is_zero("\0\0\0\0\0\0\0\0a", 8));
+  tt_int_op(0, OP_EQ, safe_mem_is_zero("\0\0\0\0\0\0\0\0a", 9));
 
  done:
   ;
@@ -4172,12 +4172,12 @@ static void
 test_util_n_bits_set(void *ptr)
 {
   (void)ptr;
-  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));
+  tt_int_op(0,OP_EQ, n_bits_set_u8(0));
+  tt_int_op(1,OP_EQ, n_bits_set_u8(1));
+  tt_int_op(3,OP_EQ, n_bits_set_u8(7));
+  tt_int_op(1,OP_EQ, n_bits_set_u8(8));
+  tt_int_op(2,OP_EQ, n_bits_set_u8(129));
+  tt_int_op(8,OP_EQ, n_bits_set_u8(255));
  done:
   ;
 }
@@ -4198,78 +4198,78 @@ test_util_eat_whitespace(void *ptr)
   strlcpy(str, "fuubaar", sizeof(str));
   for (i = 0; i < sizeof(ws); ++i) {
     str[0] = ws[i];
-    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)));
+    tt_ptr_op(str + 1,OP_EQ, eat_whitespace(str));
+    tt_ptr_op(str + 1,OP_EQ, eat_whitespace_eos(str, str + strlen(str)));
+    tt_ptr_op(str + 1,OP_EQ, eat_whitespace_no_nl(str));
+    tt_ptr_op(str + 1,OP_EQ, eat_whitespace_eos_no_nl(str, str + strlen(str)));
   }
   str[0] = '\n';
-  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)));
+  tt_ptr_op(str + 1,OP_EQ, eat_whitespace(str));
+  tt_ptr_op(str + 1,OP_EQ, eat_whitespace_eos(str, str + strlen(str)));
+  tt_ptr_op(str,OP_EQ,     eat_whitespace_no_nl(str));
+  tt_ptr_op(str,OP_EQ,     eat_whitespace_eos_no_nl(str, str + strlen(str)));
 
   /* Empty string */
   strlcpy(str, "", sizeof(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));
+  tt_ptr_op(str,OP_EQ, eat_whitespace(str));
+  tt_ptr_op(str,OP_EQ, eat_whitespace_eos(str, str));
+  tt_ptr_op(str,OP_EQ, eat_whitespace_no_nl(str));
+  tt_ptr_op(str,OP_EQ, eat_whitespace_eos_no_nl(str, str));
 
   /* Only ws */
   strlcpy(str, " \t\r\n", sizeof(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 + strlen(str) - 1,==,
+  tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace(str));
+  tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace_eos(str, str + strlen(str)));
+  tt_ptr_op(str + strlen(str) - 1,OP_EQ,
               eat_whitespace_no_nl(str));
-  tt_ptr_op(str + strlen(str) - 1,==,
+  tt_ptr_op(str + strlen(str) - 1,OP_EQ,
               eat_whitespace_eos_no_nl(str, str + strlen(str)));
 
   strlcpy(str, " \t\r ", sizeof(str));
-  tt_ptr_op(str + strlen(str),==, eat_whitespace(str));
-  tt_ptr_op(str + strlen(str),==,
+  tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace(str));
+  tt_ptr_op(str + strlen(str),OP_EQ,
               eat_whitespace_eos(str, str + strlen(str)));
-  tt_ptr_op(str + strlen(str),==, eat_whitespace_no_nl(str));
-  tt_ptr_op(str + strlen(str),==,
+  tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace_no_nl(str));
+  tt_ptr_op(str + strlen(str),OP_EQ,
               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];
-  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),==,
+  tt_ptr_op(str + sizeof(ws),OP_EQ, eat_whitespace(str));
+  tt_ptr_op(str + sizeof(ws),OP_EQ, eat_whitespace_eos(str, str + strlen(str)));
+  tt_ptr_op(str + sizeof(ws),OP_EQ, eat_whitespace_no_nl(str));
+  tt_ptr_op(str + sizeof(ws),OP_EQ,
               eat_whitespace_eos_no_nl(str, str + strlen(str)));
 
   /* Eat comment */
   strlcpy(str, "# Comment \n No Comment", sizeof(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)));
+  tt_str_op("No Comment",OP_EQ, eat_whitespace(str));
+  tt_str_op("No Comment",OP_EQ, eat_whitespace_eos(str, str + strlen(str)));
+  tt_ptr_op(str,OP_EQ, eat_whitespace_no_nl(str));
+  tt_ptr_op(str,OP_EQ, eat_whitespace_eos_no_nl(str, str + strlen(str)));
 
   /* Eat comment & ws mix */
   strlcpy(str, " # \t Comment \n\t\nNo Comment", sizeof(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)));
+  tt_str_op("No Comment",OP_EQ, eat_whitespace(str));
+  tt_str_op("No Comment",OP_EQ, eat_whitespace_eos(str, str + strlen(str)));
+  tt_ptr_op(str + 1,OP_EQ, eat_whitespace_no_nl(str));
+  tt_ptr_op(str + 1,OP_EQ, eat_whitespace_eos_no_nl(str, str + strlen(str)));
 
   /* Eat entire comment */
   strlcpy(str, "#Comment", sizeof(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)));
+  tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace(str));
+  tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace_eos(str, str + strlen(str)));
+  tt_ptr_op(str,OP_EQ, eat_whitespace_no_nl(str));
+  tt_ptr_op(str,OP_EQ, eat_whitespace_eos_no_nl(str, str + strlen(str)));
 
   /* Blank line, then comment */
   strlcpy(str, " \t\n # Comment", sizeof(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)));
+  tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace(str));
+  tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace_eos(str, str + strlen(str)));
+  tt_ptr_op(str + 2,OP_EQ, eat_whitespace_no_nl(str));
+  tt_ptr_op(str + 2,OP_EQ, eat_whitespace_eos_no_nl(str, str + strlen(str)));
 
  done:
   ;
@@ -4308,11 +4308,11 @@ test_util_sl_new_from_text_lines(void *ptr)
     smartlist_t *sl = smartlist_new_from_text_lines("foo\nbar\nbaz\n");
     int sl_len = smartlist_len(sl);
 
-    tt_want_int_op(sl_len, ==, 3);
+    tt_want_int_op(sl_len, OP_EQ, 3);
 
-    if (sl_len > 0) tt_want_str_op(smartlist_get(sl, 0), ==, "foo");
-    if (sl_len > 1) tt_want_str_op(smartlist_get(sl, 1), ==, "bar");
-    if (sl_len > 2) tt_want_str_op(smartlist_get(sl, 2), ==, "baz");
+    if (sl_len > 0) tt_want_str_op(smartlist_get(sl, 0), OP_EQ, "foo");
+    if (sl_len > 1) tt_want_str_op(smartlist_get(sl, 1), OP_EQ, "bar");
+    if (sl_len > 2) tt_want_str_op(smartlist_get(sl, 2), OP_EQ, "baz");
 
     SMARTLIST_FOREACH(sl, void *, x, tor_free(x));
     smartlist_free(sl);
@@ -4322,11 +4322,11 @@ test_util_sl_new_from_text_lines(void *ptr)
     smartlist_t *sl = smartlist_new_from_text_lines("foo\nbar\nbaz");
     int sl_len = smartlist_len(sl);
 
-    tt_want_int_op(sl_len, ==, 3);
+    tt_want_int_op(sl_len, OP_EQ, 3);
 
-    if (sl_len > 0) tt_want_str_op(smartlist_get(sl, 0), ==, "foo");
-    if (sl_len > 1) tt_want_str_op(smartlist_get(sl, 1), ==, "bar");
-    if (sl_len > 2) tt_want_str_op(smartlist_get(sl, 2), ==, "baz");
+    if (sl_len > 0) tt_want_str_op(smartlist_get(sl, 0), OP_EQ, "foo");
+    if (sl_len > 1) tt_want_str_op(smartlist_get(sl, 1), OP_EQ, "bar");
+    if (sl_len > 2) tt_want_str_op(smartlist_get(sl, 2), OP_EQ, "baz");
 
     SMARTLIST_FOREACH(sl, void *, x, tor_free(x));
     smartlist_free(sl);
@@ -4336,9 +4336,9 @@ test_util_sl_new_from_text_lines(void *ptr)
     smartlist_t *sl = smartlist_new_from_text_lines("foo");
     int sl_len = smartlist_len(sl);
 
-    tt_want_int_op(sl_len, ==, 1);
+    tt_want_int_op(sl_len, OP_EQ, 1);
 
-    if (sl_len > 0) tt_want_str_op(smartlist_get(sl, 0), ==, "foo");
+    if (sl_len > 0) tt_want_str_op(smartlist_get(sl, 0), OP_EQ, "foo");
 
     SMARTLIST_FOREACH(sl, void *, x, tor_free(x));
     smartlist_free(sl);
@@ -4348,7 +4348,7 @@ test_util_sl_new_from_text_lines(void *ptr)
     smartlist_t *sl = smartlist_new_from_text_lines("");
     int sl_len = smartlist_len(sl);
 
-    tt_want_int_op(sl_len, ==, 0);
+    tt_want_int_op(sl_len, OP_EQ, 0);
 
     SMARTLIST_FOREACH(sl, void *, x, tor_free(x));
     smartlist_free(sl);
@@ -4431,7 +4431,7 @@ test_util_make_environment(void *ptr)
   smartlist_sort_strings(env_vars_sorted);
   smartlist_sort_strings(env_vars_in_unixoid_env_block_sorted);
 
-  tt_want_int_op(smartlist_len(env_vars_sorted), ==,
+  tt_want_int_op(smartlist_len(env_vars_sorted), OP_EQ,
                  smartlist_len(env_vars_in_unixoid_env_block_sorted));
   {
     int len = smartlist_len(env_vars_sorted);
@@ -4442,7 +4442,7 @@ test_util_make_environment(void *ptr)
     }
 
     for (i = 0; i < len; ++i) {
-      tt_want_str_op(smartlist_get(env_vars_sorted, i), ==,
+      tt_want_str_op(smartlist_get(env_vars_sorted, i), OP_EQ,
                      smartlist_get(env_vars_in_unixoid_env_block_sorted, i));
     }
   }
@@ -4524,7 +4524,7 @@ test_util_set_env_var_in_sl(void *ptr)
   smartlist_sort_strings(merged_env_vars);
   smartlist_sort_strings(expected_resulting_env_vars);
 
-  tt_want_int_op(smartlist_len(merged_env_vars), ==,
+  tt_want_int_op(smartlist_len(merged_env_vars), OP_EQ,
                  smartlist_len(expected_resulting_env_vars));
   {
     int len = smartlist_len(merged_env_vars);
@@ -4535,7 +4535,7 @@ test_util_set_env_var_in_sl(void *ptr)
     }
 
     for (i = 0; i < len; ++i) {
-      tt_want_str_op(smartlist_get(merged_env_vars, i), ==,
+      tt_want_str_op(smartlist_get(merged_env_vars, i), OP_EQ,
                      smartlist_get(expected_resulting_env_vars, i));
     }
   }
@@ -4562,8 +4562,8 @@ test_util_weak_random(void *arg)
   for (i = 1; i <= 256; ++i) {
     for (j=0;j<100;++j) {
       int r = tor_weak_random_range(&rng, i);
-      tt_int_op(0, <=, r);
-      tt_int_op(r, <, i);
+      tt_int_op(0, OP_LE, r);
+      tt_int_op(r, OP_LT, i);
     }
   }
 
@@ -4573,7 +4573,7 @@ test_util_weak_random(void *arg)
   }
 
   for (i=0;i<16;++i)
-    tt_int_op(n[i], >, 0);
+    tt_int_op(n[i], OP_GT, 0);
  done:
   ;
 }
@@ -4585,9 +4585,9 @@ test_util_mathlog(void *arg)
   (void) arg;
 
   d = tor_mathlog(2.718281828);
-  tt_double_op(fabs(d - 1.0), <, .000001);
+  tt_double_op(fabs(d - 1.0), OP_LT, .000001);
   d = tor_mathlog(10);
-  tt_double_op(fabs(d - 2.30258509), <, .000001);
+  tt_double_op(fabs(d - 2.30258509), OP_LT, .000001);
  done:
   ;
 }
@@ -4671,36 +4671,36 @@ test_util_socket(void *arg)
   fd2 = tor_open_socket_with_extensions(AF_INET, SOCK_STREAM, 0, 0, 1);
   tt_assert(SOCKET_OK(fd1));
   tt_assert(SOCKET_OK(fd2));
-  tt_int_op(get_n_open_sockets(), ==, n + 2);
+  tt_int_op(get_n_open_sockets(), OP_EQ, n + 2);
   //fd3 = tor_open_socket_with_extensions(AF_INET, SOCK_STREAM, 0, 1, 0);
   //fd4 = tor_open_socket_with_extensions(AF_INET, SOCK_STREAM, 0, 1, 1);
   fd3 = tor_open_socket(AF_INET, SOCK_STREAM, 0);
   fd4 = tor_open_socket_nonblocking(AF_INET, SOCK_STREAM, 0);
   tt_assert(SOCKET_OK(fd3));
   tt_assert(SOCKET_OK(fd4));
-  tt_int_op(get_n_open_sockets(), ==, n + 4);
+  tt_int_op(get_n_open_sockets(), OP_EQ, n + 4);
 
 #ifdef CAN_CHECK_CLOEXEC
-  tt_int_op(fd_is_cloexec(fd1), ==, 0);
-  tt_int_op(fd_is_cloexec(fd2), ==, 0);
-  tt_int_op(fd_is_cloexec(fd3), ==, 1);
-  tt_int_op(fd_is_cloexec(fd4), ==, 1);
+  tt_int_op(fd_is_cloexec(fd1), OP_EQ, 0);
+  tt_int_op(fd_is_cloexec(fd2), OP_EQ, 0);
+  tt_int_op(fd_is_cloexec(fd3), OP_EQ, 1);
+  tt_int_op(fd_is_cloexec(fd4), OP_EQ, 1);
 #endif
 #ifdef CAN_CHECK_NONBLOCK
-  tt_int_op(fd_is_nonblocking(fd1), ==, 0);
-  tt_int_op(fd_is_nonblocking(fd2), ==, 1);
-  tt_int_op(fd_is_nonblocking(fd3), ==, 0);
-  tt_int_op(fd_is_nonblocking(fd4), ==, 1);
+  tt_int_op(fd_is_nonblocking(fd1), OP_EQ, 0);
+  tt_int_op(fd_is_nonblocking(fd2), OP_EQ, 1);
+  tt_int_op(fd_is_nonblocking(fd3), OP_EQ, 0);
+  tt_int_op(fd_is_nonblocking(fd4), OP_EQ, 1);
 #endif
 
   tor_close_socket(fd1);
   tor_close_socket(fd2);
   fd1 = fd2 = TOR_INVALID_SOCKET;
-  tt_int_op(get_n_open_sockets(), ==, n + 2);
+  tt_int_op(get_n_open_sockets(), OP_EQ, n + 2);
   tor_close_socket(fd3);
   tor_close_socket(fd4);
   fd3 = fd4 = TOR_INVALID_SOCKET;
-  tt_int_op(get_n_open_sockets(), ==, n);
+  tt_int_op(get_n_open_sockets(), OP_EQ, n);
 
  done:
   if (SOCKET_OK(fd1))
@@ -4742,17 +4742,17 @@ test_util_socketpair(void *arg)
   tor_socket_t fds[2] = {TOR_INVALID_SOCKET, TOR_INVALID_SOCKET};
   const int family = AF_UNIX;
 
-  tt_int_op(0, ==, tor_socketpair_fn(family, SOCK_STREAM, 0, fds));
+  tt_int_op(0, OP_EQ, tor_socketpair_fn(family, SOCK_STREAM, 0, fds));
   tt_assert(SOCKET_OK(fds[0]));
   tt_assert(SOCKET_OK(fds[1]));
-  tt_int_op(get_n_open_sockets(), ==, n + 2);
+  tt_int_op(get_n_open_sockets(), OP_EQ, n + 2);
 #ifdef CAN_CHECK_CLOEXEC
-  tt_int_op(fd_is_cloexec(fds[0]), ==, 1);
-  tt_int_op(fd_is_cloexec(fds[1]), ==, 1);
+  tt_int_op(fd_is_cloexec(fds[0]), OP_EQ, 1);
+  tt_int_op(fd_is_cloexec(fds[1]), OP_EQ, 1);
 #endif
 #ifdef CAN_CHECK_NONBLOCK
-  tt_int_op(fd_is_nonblocking(fds[0]), ==, 0);
-  tt_int_op(fd_is_nonblocking(fds[1]), ==, 0);
+  tt_int_op(fd_is_nonblocking(fds[0]), OP_EQ, 0);
+  tt_int_op(fd_is_nonblocking(fds[1]), OP_EQ, 0);
 #endif
 
  done:
@@ -4771,18 +4771,18 @@ test_util_max_mem(void *arg)
 
   r = get_total_system_memory(&memory1);
   r2 = get_total_system_memory(&memory2);
-  tt_int_op(r, ==, r2);
-  tt_uint_op(memory2, ==, memory1);
+  tt_int_op(r, OP_EQ, r2);
+  tt_uint_op(memory2, OP_EQ, memory1);
 
   TT_BLATHER(("System memory: "U64_FORMAT, U64_PRINTF_ARG(memory1)));
 
   if (r==0) {
     /* You have at least a megabyte. */
-    tt_uint_op(memory1, >, (1<<20));
+    tt_uint_op(memory1, OP_GT, (1<<20));
   } else {
     /* You do not have a petabyte. */
 #if SIZEOF_SIZE_T == SIZEOF_UINT64_T
-    tt_uint_op(memory1, <, (U64_LITERAL(1)<<50));
+    tt_uint_op(memory1, OP_LT, (U64_LITERAL(1)<<50));
 #endif
   }
 



_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits