Merge branch 'ahf_bug22497_redux'

1 files changed, 46 insertions, 46 deletions

diff --git a/src/test/test_entrynodes.c b/src/test/test_entrynodes.c
index 1f008d93b3..f30bb5ffa1 100644
--- a/src/test/test_entrynodes.c
+++ b/src/test/test_entrynodes.c
@@ -455,29 +455,29 @@ test_entry_guard_parse_from_state_failure(void *arg)
   /* no selection */
   eg = entry_guard_parse_from_state(
                  "rsa_id=596f75206d6179206e656564206120686f626270");
-  tt_assert(! eg);
+  tt_ptr_op(eg, OP_EQ, NULL);
 
   /* no RSA ID. */
   eg = entry_guard_parse_from_state("in=default nickname=Fred");
-  tt_assert(! eg);
+  tt_ptr_op(eg, OP_EQ, NULL);
 
   /* Bad RSA ID: bad character. */
   eg = entry_guard_parse_from_state(
                  "in=default "
                  "rsa_id=596f75206d6179206e656564206120686f62627q");
-  tt_assert(! eg);
+  tt_ptr_op(eg, OP_EQ, NULL);
 
   /* Bad RSA ID: too long.*/
   eg = entry_guard_parse_from_state(
                  "in=default "
                  "rsa_id=596f75206d6179206e656564206120686f6262703");
-  tt_assert(! eg);
+  tt_ptr_op(eg, OP_EQ, NULL);
 
   /* Bad RSA ID: too short.*/
   eg = entry_guard_parse_from_state(
                  "in=default "
                  "rsa_id=596f75206d6179206e65656420612");
-  tt_assert(! eg);
+  tt_ptr_op(eg, OP_EQ, NULL);
 
  done:
   entry_guard_free(eg);
@@ -595,20 +595,20 @@ test_entry_guard_parse_from_state_full(void *arg)
   MOCK(get_or_state,
        get_or_state_replacement);
 
-  tt_assert(r == 0);
+  tt_int_op(r, OP_EQ, 0);
   tt_assert(lines);
 
   state->Guard = lines;
 
   /* Try it first without setting the result. */
   r = entry_guards_parse_state(state, 0, &msg);
-  tt_assert(r == 0);
+  tt_int_op(r, OP_EQ, 0);
   guard_selection_t *gs_br =
     get_guard_selection_by_name("bridges", GS_TYPE_BRIDGE, 0);
-  tt_assert(!gs_br);
+  tt_ptr_op(gs_br, OP_EQ, NULL);
 
   r = entry_guards_parse_state(state, 1, &msg);
-  tt_assert(r == 0);
+  tt_int_op(r, OP_EQ, 0);
   gs_br = get_guard_selection_by_name("bridges", GS_TYPE_BRIDGE, 0);
   guard_selection_t *gs_df =
     get_guard_selection_by_name("default", GS_TYPE_NORMAL, 0);
@@ -625,7 +625,7 @@ test_entry_guard_parse_from_state_full(void *arg)
 
   /* Try again; make sure it doesn't double-add the guards. */
   r = entry_guards_parse_state(state, 1, &msg);
-  tt_assert(r == 0);
+  tt_int_op(r, OP_EQ, 0);
   gs_br = get_guard_selection_by_name("bridges", GS_TYPE_BRIDGE, 0);
   gs_df = get_guard_selection_by_name("default", GS_TYPE_NORMAL, 0);
   tt_assert(gs_br);
@@ -730,7 +730,7 @@ test_entry_guard_parse_from_state_broken(void *arg)
   MOCK(get_or_state,
        get_or_state_replacement);
 
-  tt_assert(r == 0);
+  tt_int_op(r, OP_EQ, 0);
   tt_assert(lines);
 
   state->Guard = lines;
@@ -742,7 +742,7 @@ test_entry_guard_parse_from_state_broken(void *arg)
   /* And we shouldn't have made anything. */
   guard_selection_t *gs_df =
     get_guard_selection_by_name("default", GS_TYPE_NORMAL, 0);
-  tt_assert(gs_df == NULL);
+  tt_ptr_op(gs_df, OP_EQ, NULL);
   tor_free(msg);
 
   /* Now see about the set case (which shouldn't happen IRL) */
@@ -750,7 +750,7 @@ test_entry_guard_parse_from_state_broken(void *arg)
   tt_int_op(r, OP_LT, 0);
   tt_ptr_op(msg, OP_NE, NULL);
   gs_df = get_guard_selection_by_name("default", GS_TYPE_NORMAL, 0);
-  tt_assert(gs_df != NULL);
+  tt_ptr_op(gs_df, OP_NE, NULL);
   tt_int_op(smartlist_len(gs_df->sampled_entry_guards), OP_EQ, 1);
 
  done:
@@ -767,26 +767,26 @@ test_entry_guard_get_guard_selection_by_name(void *arg)
   guard_selection_t *gs1, *gs2, *gs3;
 
   gs1 = get_guard_selection_by_name("unlikely", GS_TYPE_NORMAL, 0);
-  tt_assert(gs1 == NULL);
+  tt_ptr_op(gs1, OP_EQ, NULL);
   gs1 = get_guard_selection_by_name("unlikely", GS_TYPE_NORMAL, 1);
-  tt_assert(gs1 != NULL);
+  tt_ptr_op(gs1, OP_NE, NULL);
   gs2 = get_guard_selection_by_name("unlikely", GS_TYPE_NORMAL, 1);
   tt_assert(gs2 == gs1);
   gs2 = get_guard_selection_by_name("unlikely", GS_TYPE_NORMAL, 0);
   tt_assert(gs2 == gs1);
 
   gs2 = get_guard_selection_by_name("implausible", GS_TYPE_NORMAL, 0);
-  tt_assert(gs2 == NULL);
+  tt_ptr_op(gs2, OP_EQ, NULL);
   gs2 = get_guard_selection_by_name("implausible", GS_TYPE_NORMAL, 1);
-  tt_assert(gs2 != NULL);
+  tt_ptr_op(gs2, OP_NE, NULL);
   tt_assert(gs2 != gs1);
   gs3 = get_guard_selection_by_name("implausible", GS_TYPE_NORMAL, 0);
   tt_assert(gs3 == gs2);
 
   gs3 = get_guard_selection_by_name("default", GS_TYPE_NORMAL, 0);
-  tt_assert(gs3 == NULL);
+  tt_ptr_op(gs3, OP_EQ, NULL);
   gs3 = get_guard_selection_by_name("default", GS_TYPE_NORMAL, 1);
-  tt_assert(gs3 != NULL);
+  tt_ptr_op(gs3, OP_NE, NULL);
   tt_assert(gs3 != gs2);
   tt_assert(gs3 != gs1);
   tt_assert(gs3 == get_guard_selection_info());
@@ -847,16 +847,16 @@ test_entry_guard_add_single_guard(void *arg)
   tt_i64_op(g1->sampled_on_date, OP_GE, now - 12*86400);
   tt_i64_op(g1->sampled_on_date, OP_LE, now);
   tt_str_op(g1->sampled_by_version, OP_EQ, VERSION);
-  tt_assert(g1->currently_listed == 1);
+  tt_uint_op(g1->currently_listed, OP_EQ, 1);
   tt_i64_op(g1->confirmed_on_date, OP_EQ, 0);
   tt_int_op(g1->confirmed_idx, OP_EQ, -1);
   tt_int_op(g1->last_tried_to_connect, OP_EQ, 0);
   tt_uint_op(g1->is_reachable, OP_EQ, GUARD_REACHABLE_MAYBE);
   tt_i64_op(g1->failing_since, OP_EQ, 0);
-  tt_assert(g1->is_filtered_guard == 1);
-  tt_assert(g1->is_usable_filtered_guard == 1);
-  tt_assert(g1->is_primary == 0);
-  tt_assert(g1->extra_state_fields == NULL);
+  tt_uint_op(g1->is_filtered_guard, OP_EQ, 1);
+  tt_uint_op(g1->is_usable_filtered_guard, OP_EQ, 1);
+  tt_uint_op(g1->is_primary, OP_EQ, 0);
+  tt_ptr_op(g1->extra_state_fields, OP_EQ, NULL);
 
   /* Make sure it got added. */
   tt_int_op(1, OP_EQ, smartlist_len(gs->sampled_entry_guards));
@@ -886,16 +886,16 @@ test_entry_guard_node_filter(void *arg)
     g[i] = entry_guard_add_to_sample(gs, n[i]);
 
     // everything starts out filtered-in
-    tt_assert(g[i]->is_filtered_guard == 1);
-    tt_assert(g[i]->is_usable_filtered_guard == 1);
+    tt_uint_op(g[i]->is_filtered_guard, OP_EQ, 1);
+    tt_uint_op(g[i]->is_usable_filtered_guard, OP_EQ, 1);
   }
   tt_int_op(num_reachable_filtered_guards(gs, NULL), OP_EQ, NUM);
 
   /* Make sure refiltering doesn't hurt */
   entry_guards_update_filtered_sets(gs);
   for (i = 0; i < NUM; ++i) {
-    tt_assert(g[i]->is_filtered_guard == 1);
-    tt_assert(g[i]->is_usable_filtered_guard == 1);
+    tt_uint_op(g[i]->is_filtered_guard, OP_EQ, 1);
+    tt_uint_op(g[i]->is_usable_filtered_guard, OP_EQ, 1);
   }
   tt_int_op(num_reachable_filtered_guards(gs, NULL), OP_EQ, NUM);
 
@@ -948,8 +948,8 @@ test_entry_guard_node_filter(void *arg)
   });
   entry_guards_update_filtered_sets(gs);
   for (i = 0; i < NUM; ++i) {
-    tt_assert(g[i]->is_filtered_guard == 0);
-    tt_assert(g[i]->is_usable_filtered_guard == 0);
+    tt_uint_op(g[i]->is_filtered_guard, OP_EQ, 0);
+    tt_uint_op(g[i]->is_usable_filtered_guard, OP_EQ, 0);
   }
   tt_int_op(num_reachable_filtered_guards(gs, NULL), OP_EQ, 0);
 
@@ -992,7 +992,7 @@ test_entry_guard_expand_sample(void *arg)
   // Nothing became unusable/unfiltered, so a subsequent expand should
   // make no changes.
   guard = entry_guards_expand_sample(gs);
-  tt_assert(! guard); // no guard was added.
+  tt_ptr_op(guard, OP_EQ, NULL); // no guard was added.
   tt_int_op(DFLT_MIN_FILTERED_SAMPLE_SIZE, OP_EQ,
             num_reachable_filtered_guards(gs, NULL));
 
@@ -1016,7 +1016,7 @@ test_entry_guard_expand_sample(void *arg)
 
   // Still idempotent.
   guard = entry_guards_expand_sample(gs);
-  tt_assert(! guard); // no guard was added.
+  tt_ptr_op(guard, OP_EQ, NULL); // no guard was added.
   tt_int_op(DFLT_MIN_FILTERED_SAMPLE_SIZE, OP_EQ,
             num_reachable_filtered_guards(gs, NULL));
 
@@ -1707,7 +1707,7 @@ test_entry_guard_select_for_circuit_no_confirmed(void *arg)
   tt_assert(g);
   tt_assert(g->is_primary);
   tt_int_op(g->confirmed_idx, OP_EQ, -1);
-  tt_assert(g->is_pending == 0); // primary implies non-pending.
+  tt_uint_op(g->is_pending, OP_EQ, 0); // primary implies non-pending.
   tt_uint_op(state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
   tt_i64_op(g->last_tried_to_connect, OP_EQ, approx_time());
 
@@ -1727,7 +1727,7 @@ test_entry_guard_select_for_circuit_no_confirmed(void *arg)
   tt_assert(g2);
   tt_assert(g2->is_primary);
   tt_int_op(g2->confirmed_idx, OP_EQ, -1);
-  tt_assert(g2->is_pending == 0); // primary implies non-pending.
+  tt_uint_op(g2->is_pending, OP_EQ, 0); // primary implies non-pending.
   tt_uint_op(state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
   tt_i64_op(g2->last_tried_to_connect, OP_EQ, approx_time());
 
@@ -1755,7 +1755,7 @@ test_entry_guard_select_for_circuit_no_confirmed(void *arg)
   tt_assert(g2);
   tt_assert(!g2->is_primary);
   tt_int_op(g2->confirmed_idx, OP_EQ, -1);
-  tt_assert(g2->is_pending == 1);
+  tt_uint_op(g2->is_pending, OP_EQ, 1);
   tt_uint_op(state, OP_EQ, GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD);
   tt_i64_op(g2->last_tried_to_connect, OP_EQ, approx_time());
   tt_int_op(g2->is_reachable, OP_EQ, GUARD_REACHABLE_MAYBE);
@@ -1813,7 +1813,7 @@ test_entry_guard_select_for_circuit_confirmed(void *arg)
   tt_assert(g);
   tt_assert(g->is_primary);
   tt_int_op(g->confirmed_idx, OP_EQ, 0);
-  tt_assert(g->is_pending == 0); // primary implies non-pending.
+  tt_uint_op(g->is_pending, OP_EQ, 0); // primary implies non-pending.
   tt_uint_op(state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
   tt_i64_op(g->last_tried_to_connect, OP_EQ, approx_time());
   tt_ptr_op(g, OP_EQ, smartlist_get(gs->primary_entry_guards, 0));
@@ -1913,7 +1913,7 @@ test_entry_guard_select_for_circuit_highlevel_primary(void *arg)
   int r = entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
                                        &node, &guard);
 
-  tt_assert(r == 0);
+  tt_int_op(r, OP_EQ, 0);
   tt_assert(node);
   tt_assert(guard);
   tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
@@ -1945,7 +1945,7 @@ test_entry_guard_select_for_circuit_highlevel_primary(void *arg)
   update_approx_time(start+35);
   r = entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
                                    &node, &guard);
-  tt_assert(r == 0);
+  tt_int_op(r, OP_EQ, 0);
   tt_assert(node);
   tt_assert(guard);
   tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
@@ -1981,7 +1981,7 @@ test_entry_guard_select_for_circuit_highlevel_primary(void *arg)
   update_approx_time(start+60);
   r = entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
                                    &node, &guard);
-  tt_assert(r == 0);
+  tt_int_op(r, OP_EQ, 0);
   tt_assert(node);
   tt_assert(guard);
   tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
@@ -2036,7 +2036,7 @@ test_entry_guard_select_for_circuit_highlevel_confirm_other(void *arg)
                                      &node, &guard);
     tt_assert(node);
     tt_assert(guard);
-    tt_assert(r == 0);
+    tt_int_op(r, OP_EQ, 0);
     tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
     entry_guard_failed(&guard);
     circuit_guard_state_free(guard);
@@ -2050,7 +2050,7 @@ test_entry_guard_select_for_circuit_highlevel_confirm_other(void *arg)
                                    &node, &guard);
   tt_assert(node);
   tt_assert(guard);
-  tt_assert(r == 0);
+  tt_int_op(r, OP_EQ, 0);
   entry_guard_t *g = entry_guard_handle_get(guard->guard);
   tt_assert(g);
   tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD);
@@ -2102,7 +2102,7 @@ test_entry_guard_select_for_circuit_highlevel_primary_retry(void *arg)
                                      &node, &guard);
     tt_assert(node);
     tt_assert(guard);
-    tt_assert(r == 0);
+    tt_int_op(r, OP_EQ, 0);
     tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
     g = entry_guard_handle_get(guard->guard);
     make_guard_confirmed(gs, g);
@@ -2119,7 +2119,7 @@ test_entry_guard_select_for_circuit_highlevel_primary_retry(void *arg)
                                    &node, &guard);
   tt_assert(node);
   tt_assert(guard);
-  tt_assert(r == 0);
+  tt_int_op(r, OP_EQ, 0);
   tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD);
   g = entry_guard_handle_get(guard->guard);
   tt_int_op(g->is_primary, OP_EQ, 0);
@@ -2145,7 +2145,7 @@ test_entry_guard_select_for_circuit_highlevel_primary_retry(void *arg)
   /* Have a circuit to a primary guard succeed. */
   r = entry_guard_pick_for_circuit(gs, GUARD_USAGE_TRAFFIC, NULL,
                                    &node, &guard2);
-  tt_assert(r == 0);
+  tt_int_op(r, OP_EQ, 0);
   tt_int_op(guard2->state, OP_EQ, GUARD_CIRC_STATE_USABLE_ON_COMPLETION);
   u = entry_guard_succeeded(&guard2);
   tt_assert(u == GUARD_USABLE_NOW);
@@ -2194,7 +2194,7 @@ test_entry_guard_select_and_cancel(void *arg)
                                    &node, &guard);
   tt_assert(node);
   tt_assert(guard);
-  tt_assert(r == 0);
+  tt_int_op(r, OP_EQ, 0);
   tt_int_op(guard->state, OP_EQ, GUARD_CIRC_STATE_USABLE_IF_NO_BETTER_GUARD);
   g = entry_guard_handle_get(guard->guard);
   tt_int_op(g->is_primary, OP_EQ, 0);
@@ -2202,7 +2202,7 @@ test_entry_guard_select_and_cancel(void *arg)
 
   /* Whoops! We should never have asked for this guard. Cancel the request! */
   entry_guard_cancel(&guard);
-  tt_assert(guard == NULL);
+  tt_ptr_op(guard, OP_EQ, NULL);
   tt_int_op(g->is_primary, OP_EQ, 0);
   tt_int_op(g->is_pending, OP_EQ, 0);