Replace operators used as macro arguments with OP_XX macros

Part of fix for 13172

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));

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:
 	;

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 ||

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);

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",   \

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);

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:

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));

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);

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);
   }
 

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);

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");
 

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

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);

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

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();

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:

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);
 

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:

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);

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;

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);

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;

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:
 

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@192.0.2.1:1080");
+  tt_str_op(uri, OP_EQ, "socks5://hwest:r34n1m470r@192.0.2.1: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@192.0.2.1:80");
+  tt_str_op(uri, OP_EQ, "http://hwest:r34n1m470r@192.0.2.1: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);
 

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);

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);
 

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);
 

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:
     ;

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:
   ;

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