commit a3dafd3f58bb3122b9de919e931c02b5e12373b2 Author: Nick Mathewson nickm@torproject.org Date: Wed Nov 12 13:28:07 2014 -0500

Replace operators used as macro arguments with OP_XX macros

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

diff --git a/src/common/compat_libevent.c b/src/common/compat_libevent.c index 33672f0..4cfe5cc 100644 --- a/src/common/compat_libevent.c +++ b/src/common/compat_libevent.c @@ -717,7 +717,7 @@ tor_gettimeofday_cached_monotonic(struct timeval *tv) struct timeval last_tv = { 0, 0 };

tor_gettimeofday_cached(tv); - if (timercmp(tv, &last_tv, <)) { + if (timercmp(tv, &last_tv, OP_LT)) { memcpy(tv, &last_tv, sizeof(struct timeval)); } else { memcpy(&last_tv, tv, sizeof(struct timeval)); diff --git a/src/ext/tinytest_demo.c b/src/ext/tinytest_demo.c index 634e112..c07f099 100644 --- a/src/ext/tinytest_demo.c +++ b/src/ext/tinytest_demo.c @@ -74,13 +74,13 @@ test_strcmp(void *data) values of the failing things.

Fail unless strcmp("abc, "abc") == 0 */ - tt_int_op(strcmp("abc", "abc"), ==, 0); + tt_int_op(strcmp("abc", "abc"), OP_EQ, 0);

/* Fail unless strcmp("abc, "abcd") is less than 0 */ - tt_int_op(strcmp("abc", "abcd"), < , 0); + tt_int_op(strcmp("abc", "abcd"), OP_LT, 0);

/* Incidentally, there's a test_str_op that uses strcmp internally. */ - tt_str_op("abc", <, "abcd"); + tt_str_op("abc", OP_LT, "abcd");

/* Every test-case function needs to finish with an "end:" @@ -153,11 +153,11 @@ test_memcpy(void *ptr) /* Let's make sure that memcpy does what we'd like. */ strcpy(db->buffer1, "String 0"); memcpy(db->buffer2, db->buffer1, sizeof(db->buffer1)); - tt_str_op(db->buffer1, ==, db->buffer2); + tt_str_op(db->buffer1, OP_EQ, db->buffer2);

/* tt_mem_op() does a memcmp, as opposed to the strcmp in tt_str_op() */ db->buffer2[100] = 3; /* Make the buffers unequal */ - tt_mem_op(db->buffer1, <, db->buffer2, sizeof(db->buffer1)); + tt_mem_op(db->buffer1, OP_LT, db->buffer2, sizeof(db->buffer1));

/* Now we've allocated memory that's referenced by a local variable. The end block of the function will clean it up. */ @@ -165,7 +165,7 @@ test_memcpy(void *ptr) tt_assert(mem);

/* Another rather trivial test. */ - tt_str_op(db->buffer1, !=, mem); + tt_str_op(db->buffer1, OP_NE, mem);

end: /* This time our end block has something to do. */ @@ -186,9 +186,9 @@ test_timeout(void *ptr) #endif t2 = time(NULL);

- tt_int_op(t2-t1, >=, 4); + tt_int_op(t2-t1, OP_GE, 4);

- tt_int_op(t2-t1, <=, 6); + tt_int_op(t2-t1, OP_LE, 6);

end: ; diff --git a/src/or/circuituse.c b/src/or/circuituse.c index 10bc45f..ad4a3a5 100644 --- a/src/or/circuituse.c +++ b/src/or/circuituse.c @@ -200,7 +200,7 @@ circuit_is_better(const origin_circuit_t *oa, const origin_circuit_t *ob, return 1; } else { if (a->timestamp_dirty || - timercmp(&a->timestamp_began, &b->timestamp_began, >)) + timercmp(&a->timestamp_began, &b->timestamp_began, OP_GT)) return 1; if (ob->build_state->is_internal) /* XXX023 what the heck is this internal thing doing here. I @@ -514,7 +514,7 @@ circuit_expire_building(void) if (TO_ORIGIN_CIRCUIT(victim)->hs_circ_has_timed_out) cutoff = hs_extremely_old_cutoff;

- if (timercmp(&victim->timestamp_began, &cutoff, >)) + if (timercmp(&victim->timestamp_began, &cutoff, OP_GT)) continue; /* it's still young, leave it alone */

/* We need to double-check the opened state here because @@ -524,7 +524,7 @@ circuit_expire_building(void) * aren't either. */ if (!any_opened_circs && victim->state != CIRCUIT_STATE_OPEN) { /* It's still young enough that we wouldn't close it, right? */ - if (timercmp(&victim->timestamp_began, &close_cutoff, >)) { + if (timercmp(&victim->timestamp_began, &close_cutoff, OP_GT)) { if (!TO_ORIGIN_CIRCUIT(victim)->relaxed_timeout) { int first_hop_succeeded = TO_ORIGIN_CIRCUIT(victim)->cpath->state == CPATH_STATE_OPEN; @@ -672,7 +672,7 @@ circuit_expire_building(void) * it off at, we probably had a suspend event along this codepath, * and we should discard the value. */ - if (timercmp(&victim->timestamp_began, &extremely_old_cutoff, <)) { + if (timercmp(&victim->timestamp_began, &extremely_old_cutoff, OP_LT)) { log_notice(LD_CIRC, "Extremely large value for circuit build timeout: %lds. " "Assuming clock jump. Purpose %d (%s)", @@ -1255,7 +1255,7 @@ circuit_expire_old_circuits_clientside(void) if (circ->purpose != CIRCUIT_PURPOSE_PATH_BIAS_TESTING) circuit_mark_for_close(circ, END_CIRC_REASON_FINISHED); } else if (!circ->timestamp_dirty && circ->state == CIRCUIT_STATE_OPEN) { - if (timercmp(&circ->timestamp_began, &cutoff, <)) { + if (timercmp(&circ->timestamp_began, &cutoff, OP_LT)) { if (circ->purpose == CIRCUIT_PURPOSE_C_GENERAL || circ->purpose == CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT || circ->purpose == CIRCUIT_PURPOSE_S_ESTABLISH_INTRO || diff --git a/src/test/test.c b/src/test/test.c index 8b74c0a..8227176 100644 --- a/src/test/test.c +++ b/src/test/test.c @@ -277,9 +277,9 @@ test_onion_handshake(void *arg) memset(c_keys, 0, 40); tt_assert(! onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40));

- tt_mem_op(c_keys,==, s_keys, 40); + tt_mem_op(c_keys,OP_EQ, s_keys, 40); memset(s_buf, 0, 40); - tt_mem_op(c_keys,!=, s_buf, 40); + tt_mem_op(c_keys,OP_NE, s_buf, 40); } done: crypto_dh_free(c_dh); @@ -311,7 +311,7 @@ test_bad_onion_handshake(void *arg) memset(junk_buf, 0, sizeof(junk_buf)); crypto_pk_public_hybrid_encrypt(pk, junk_buf2, TAP_ONIONSKIN_CHALLENGE_LEN, junk_buf, DH_KEY_LEN, PK_PKCS1_OAEP_PADDING, 1); - tt_int_op(-1, ==, + tt_int_op(-1, OP_EQ, onion_skin_TAP_server_handshake(junk_buf2, pk, NULL, s_buf, s_keys, 40));

@@ -320,7 +320,7 @@ test_bad_onion_handshake(void *arg) memset(junk_buf2, 0, sizeof(junk_buf2)); crypto_pk_public_encrypt(pk, junk_buf2, sizeof(junk_buf2), junk_buf, 48, PK_PKCS1_OAEP_PADDING); - tt_int_op(-1, ==, + tt_int_op(-1, OP_EQ, onion_skin_TAP_server_handshake(junk_buf2, pk, NULL, s_buf, s_keys, 40));

@@ -329,36 +329,36 @@ test_bad_onion_handshake(void *arg) tt_assert(! onion_skin_TAP_create(pk, &c_dh, c_buf));

/* Server: Case 3: we just don't have the right key. */ - tt_int_op(-1, ==, + tt_int_op(-1, OP_EQ, onion_skin_TAP_server_handshake(c_buf, pk2, NULL, s_buf, s_keys, 40));

/* Server: Case 4: The RSA-encrypted portion is corrupt. */ c_buf[64] ^= 33; - tt_int_op(-1, ==, + tt_int_op(-1, OP_EQ, onion_skin_TAP_server_handshake(c_buf, pk, NULL, s_buf, s_keys, 40)); c_buf[64] ^= 33;

/* (Let the server procede) */ - tt_int_op(0, ==, + tt_int_op(0, OP_EQ, onion_skin_TAP_server_handshake(c_buf, pk, NULL, s_buf, s_keys, 40));

/* Client: Case 1: The server sent back junk. */ s_buf[64] ^= 33; - tt_int_op(-1, ==, + tt_int_op(-1, OP_EQ, onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40)); s_buf[64] ^= 33;

/* Let the client finish; make sure it can. */ - tt_int_op(0, ==, + tt_int_op(0, OP_EQ, onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40)); - tt_mem_op(s_keys,==, c_keys, 40); + tt_mem_op(s_keys,OP_EQ, c_keys, 40);

/* Client: Case 2: The server sent back a degenerate DH. */ memset(s_buf, 0, sizeof(s_buf)); - tt_int_op(-1, ==, + tt_int_op(-1, OP_EQ, onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40));

done: @@ -395,24 +395,24 @@ test_ntor_handshake(void *arg)

/* client handshake 1. */ memset(c_buf, 0, NTOR_ONIONSKIN_LEN); - tt_int_op(0, ==, onion_skin_ntor_create(node_id, server_pubkey, + tt_int_op(0, OP_EQ, onion_skin_ntor_create(node_id, server_pubkey, &c_state, c_buf));

/* server handshake */ memset(s_buf, 0, NTOR_REPLY_LEN); memset(s_keys, 0, 40); - tt_int_op(0, ==, onion_skin_ntor_server_handshake(c_buf, s_keymap, NULL, + tt_int_op(0, OP_EQ, onion_skin_ntor_server_handshake(c_buf, s_keymap, NULL, node_id, s_buf, s_keys, 400));

/* client handshake 2 */ memset(c_keys, 0, 40); - tt_int_op(0, ==, onion_skin_ntor_client_handshake(c_state, s_buf, + tt_int_op(0, OP_EQ, onion_skin_ntor_client_handshake(c_state, s_buf, c_keys, 400));

- tt_mem_op(c_keys,==, s_keys, 400); + tt_mem_op(c_keys,OP_EQ, s_keys, 400); memset(s_buf, 0, 40); - tt_mem_op(c_keys,!=, s_buf, 40); + tt_mem_op(c_keys,OP_NE, s_buf, 40);

done: ntor_handshake_state_free(c_state); @@ -440,24 +440,24 @@ test_onion_queues(void *arg) create_cell_init(create2, CELL_CREATE, ONION_HANDSHAKE_TYPE_NTOR, NTOR_ONIONSKIN_LEN, buf2);

- tt_int_op(0,==, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP)); - tt_int_op(0,==, onion_pending_add(circ1, create1)); + tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP)); + tt_int_op(0,OP_EQ, onion_pending_add(circ1, create1)); create1 = NULL; - tt_int_op(1,==, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP)); + tt_int_op(1,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));

- tt_int_op(0,==, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR)); - tt_int_op(0,==, onion_pending_add(circ2, create2)); + tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR)); + tt_int_op(0,OP_EQ, onion_pending_add(circ2, create2)); create2 = NULL; - tt_int_op(1,==, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR)); + tt_int_op(1,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));

- tt_ptr_op(circ2,==, onion_next_task(&onionskin)); - tt_int_op(1,==, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP)); - tt_int_op(0,==, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR)); - tt_ptr_op(onionskin, ==, create2_ptr); + tt_ptr_op(circ2,OP_EQ, onion_next_task(&onionskin)); + tt_int_op(1,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP)); + tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR)); + tt_ptr_op(onionskin, OP_EQ, create2_ptr);

clear_pending_onions(); - tt_int_op(0,==, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP)); - tt_int_op(0,==, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR)); + tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP)); + tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));

done: circuit_free(TO_CIRCUIT(circ1)); @@ -648,13 +648,13 @@ test_rend_fns(void *arg) (void)arg; tt_assert(BAD_HOSTNAME == parse_extended_hostname(address1)); tt_assert(ONION_HOSTNAME == parse_extended_hostname(address2)); - tt_str_op(address2,==, "aaaaaaaaaaaaaaaa"); + tt_str_op(address2,OP_EQ, "aaaaaaaaaaaaaaaa"); tt_assert(EXIT_HOSTNAME == parse_extended_hostname(address3)); tt_assert(NORMAL_HOSTNAME == parse_extended_hostname(address4)); tt_assert(ONION_HOSTNAME == parse_extended_hostname(address5)); - tt_str_op(address5,==, "abcdefghijklmnop"); + tt_str_op(address5,OP_EQ, "abcdefghijklmnop"); tt_assert(ONION_HOSTNAME == parse_extended_hostname(address6)); - tt_str_op(address6,==, "abcdefghijklmnop"); + tt_str_op(address6,OP_EQ, "abcdefghijklmnop"); tt_assert(BAD_HOSTNAME == parse_extended_hostname(address7));

pk1 = pk_generate(0); @@ -693,7 +693,7 @@ test_rend_fns(void *arg) tt_assert(rend_compute_v2_desc_id(computed_desc_id, service_id_base32, NULL, now, 0) == 0); tt_mem_op(((rend_encoded_v2_service_descriptor_t *) - smartlist_get(descs, 0))->desc_id, ==, + smartlist_get(descs, 0))->desc_id, OP_EQ, computed_desc_id, DIGEST_LEN); tt_assert(rend_parse_v2_service_descriptor(&parsed, parsed_desc_id, &intro_points_encrypted, @@ -704,25 +704,25 @@ test_rend_fns(void *arg) smartlist_get(descs, 0))->desc_str) == 0); tt_assert(parsed); tt_mem_op(((rend_encoded_v2_service_descriptor_t *) - smartlist_get(descs, 0))->desc_id,==, parsed_desc_id, DIGEST_LEN); + smartlist_get(descs, 0))->desc_id,OP_EQ, parsed_desc_id, DIGEST_LEN); tt_int_op(rend_parse_introduction_points(parsed, intro_points_encrypted, - intro_points_size),==, 3); + intro_points_size),OP_EQ, 3); tt_assert(!crypto_pk_cmp_keys(generated->pk, parsed->pk)); - tt_int_op(parsed->timestamp,==, now); - tt_int_op(parsed->version,==, 2); - tt_int_op(parsed->protocols,==, 42); - tt_int_op(smartlist_len(parsed->intro_nodes),==, 3); + tt_int_op(parsed->timestamp,OP_EQ, now); + tt_int_op(parsed->version,OP_EQ, 2); + tt_int_op(parsed->protocols,OP_EQ, 42); + tt_int_op(smartlist_len(parsed->intro_nodes),OP_EQ, 3); for (i = 0; i < smartlist_len(parsed->intro_nodes); i++) { rend_intro_point_t *par_intro = smartlist_get(parsed->intro_nodes, i), *gen_intro = smartlist_get(generated->intro_nodes, i); extend_info_t *par_info = par_intro->extend_info; extend_info_t *gen_info = gen_intro->extend_info; tt_assert(!crypto_pk_cmp_keys(gen_info->onion_key, par_info->onion_key)); - tt_mem_op(gen_info->identity_digest,==, par_info->identity_digest, + tt_mem_op(gen_info->identity_digest,OP_EQ, par_info->identity_digest, DIGEST_LEN); - tt_str_op(gen_info->nickname,==, par_info->nickname); + tt_str_op(gen_info->nickname,OP_EQ, par_info->nickname); tt_assert(tor_addr_eq(&gen_info->addr, &par_info->addr)); - tt_int_op(gen_info->port,==, par_info->port); + tt_int_op(gen_info->port,OP_EQ, par_info->port); }

rend_service_descriptor_free(parsed); @@ -766,11 +766,11 @@ test_rend_fns(void *arg) } while (0) #define CHECK_COUNTRY(country, val) do { \ /* test ipv4 country lookup */ \ - tt_str_op(country, ==, \ + tt_str_op(country, OP_EQ, \ geoip_get_country_name(geoip_get_country_by_ipv4(val))); \ /* test ipv6 country lookup */ \ SET_TEST_IPV6(val); \ - tt_str_op(country, ==, \ + tt_str_op(country, OP_EQ, \ geoip_get_country_name(geoip_get_country_by_ipv6(&in6))); \ } while (0)

@@ -831,23 +831,23 @@ test_geoip(void *arg) * 'sort' step. These aren't very good IP addresses, but they're perfectly * fine uint32_t values. */ (void)arg; - tt_int_op(0,==, geoip_parse_entry("10,50,AB", AF_INET)); - tt_int_op(0,==, geoip_parse_entry("52,90,XY", AF_INET)); - tt_int_op(0,==, geoip_parse_entry("95,100,AB", AF_INET)); - tt_int_op(0,==, geoip_parse_entry(""105","140","ZZ"", AF_INET)); - tt_int_op(0,==, geoip_parse_entry(""150","190","XY"", AF_INET)); - tt_int_op(0,==, geoip_parse_entry(""200","250","AB"", AF_INET)); + tt_int_op(0,OP_EQ, geoip_parse_entry("10,50,AB", AF_INET)); + tt_int_op(0,OP_EQ, geoip_parse_entry("52,90,XY", AF_INET)); + tt_int_op(0,OP_EQ, geoip_parse_entry("95,100,AB", AF_INET)); + tt_int_op(0,OP_EQ, geoip_parse_entry(""105","140","ZZ"", AF_INET)); + tt_int_op(0,OP_EQ, geoip_parse_entry(""150","190","XY"", AF_INET)); + tt_int_op(0,OP_EQ, geoip_parse_entry(""200","250","AB"", AF_INET));

/* Populate the IPv6 DB equivalently with fake IPs in the same range */ - tt_int_op(0,==, geoip_parse_entry("::a,::32,AB", AF_INET6)); - tt_int_op(0,==, geoip_parse_entry("::34,::5a,XY", AF_INET6)); - tt_int_op(0,==, geoip_parse_entry("::5f,::64,AB", AF_INET6)); - tt_int_op(0,==, geoip_parse_entry("::69,::8c,ZZ", AF_INET6)); - tt_int_op(0,==, geoip_parse_entry("::96,::be,XY", AF_INET6)); - tt_int_op(0,==, geoip_parse_entry("::c8,::fa,AB", AF_INET6)); + tt_int_op(0,OP_EQ, geoip_parse_entry("::a,::32,AB", AF_INET6)); + tt_int_op(0,OP_EQ, geoip_parse_entry("::34,::5a,XY", AF_INET6)); + tt_int_op(0,OP_EQ, geoip_parse_entry("::5f,::64,AB", AF_INET6)); + tt_int_op(0,OP_EQ, geoip_parse_entry("::69,::8c,ZZ", AF_INET6)); + tt_int_op(0,OP_EQ, geoip_parse_entry("::96,::be,XY", AF_INET6)); + tt_int_op(0,OP_EQ, geoip_parse_entry("::c8,::fa,AB", AF_INET6));

/* We should have 4 countries: ??, ab, xy, zz. */ - tt_int_op(4,==, geoip_get_n_countries()); + tt_int_op(4,OP_EQ, geoip_get_n_countries()); memset(&in6, 0, sizeof(in6));

CHECK_COUNTRY("??", 3); @@ -858,9 +858,9 @@ test_geoip(void *arg) CHECK_COUNTRY("xy", 190); CHECK_COUNTRY("??", 2000);

- tt_int_op(0,==, geoip_get_country_by_ipv4(3)); + tt_int_op(0,OP_EQ, geoip_get_country_by_ipv4(3)); SET_TEST_IPV6(3); - tt_int_op(0,==, geoip_get_country_by_ipv6(&in6)); + tt_int_op(0,OP_EQ, geoip_get_country_by_ipv6(&in6));

get_options_mutable()->BridgeRelay = 1; get_options_mutable()->BridgeRecordUsageByCountry = 1; @@ -885,8 +885,8 @@ test_geoip(void *arg) geoip_get_client_history(GEOIP_CLIENT_CONNECT, &s, &v); tt_assert(s); tt_assert(v); - tt_str_op("zz=24,ab=16,xy=8",==, s); - tt_str_op("v4=16,v6=16",==, v); + tt_str_op("zz=24,ab=16,xy=8",OP_EQ, s); + tt_str_op("v4=16,v6=16",OP_EQ, v); tor_free(s); tor_free(v);

@@ -895,8 +895,8 @@ test_geoip(void *arg) geoip_get_client_history(GEOIP_CLIENT_CONNECT, &s, &v); tt_assert(s); tt_assert(v); - tt_str_op("zz=24,xy=8",==, s); - tt_str_op("v4=16,v6=16",==, v); + tt_str_op("zz=24,xy=8",OP_EQ, s); + tt_str_op("v4=16,v6=16",OP_EQ, v); tor_free(s); tor_free(v);

@@ -910,7 +910,7 @@ test_geoip(void *arg) geoip_bridge_stats_init(now); s = geoip_format_bridge_stats(now + 86400); tt_assert(s); - tt_str_op(bridge_stats_1,==, s); + tt_str_op(bridge_stats_1,OP_EQ, s); tor_free(s);

/* Stop collecting bridge stats and make sure we don't write a history @@ -939,7 +939,7 @@ test_geoip(void *arg) SET_TEST_ADDRESS(100); geoip_note_client_seen(GEOIP_CLIENT_NETWORKSTATUS, &addr, NULL, now); s = geoip_format_dirreq_stats(now + 86400); - tt_str_op(dirreq_stats_1,==, s); + tt_str_op(dirreq_stats_1,OP_EQ, s); tor_free(s);

/* Stop collecting stats, add another connecting client, and ensure we @@ -957,20 +957,20 @@ test_geoip(void *arg) geoip_note_client_seen(GEOIP_CLIENT_NETWORKSTATUS, &addr, NULL, now); geoip_reset_dirreq_stats(now); s = geoip_format_dirreq_stats(now + 86400); - tt_str_op(dirreq_stats_2,==, s); + tt_str_op(dirreq_stats_2,OP_EQ, s); tor_free(s);

/* Note a successful network status response and make sure that it * appears in the history string. */ geoip_note_ns_response(GEOIP_SUCCESS); s = geoip_format_dirreq_stats(now + 86400); - tt_str_op(dirreq_stats_3,==, s); + tt_str_op(dirreq_stats_3,OP_EQ, s); tor_free(s);

/* Start a tunneled directory request. */ geoip_start_dirreq((uint64_t) 1, 1024, DIRREQ_TUNNELED); s = geoip_format_dirreq_stats(now + 86400); - tt_str_op(dirreq_stats_4,==, s); + tt_str_op(dirreq_stats_4,OP_EQ, s); tor_free(s);

/* Stop collecting directory request statistics and start gathering @@ -992,7 +992,7 @@ test_geoip(void *arg) SET_TEST_ADDRESS(100); geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now); s = geoip_format_entry_stats(now + 86400); - tt_str_op(entry_stats_1,==, s); + tt_str_op(entry_stats_1,OP_EQ, s); tor_free(s);

/* Stop collecting stats, add another connecting client, and ensure we @@ -1010,7 +1010,7 @@ test_geoip(void *arg) geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now); geoip_reset_entry_stats(now); s = geoip_format_entry_stats(now + 86400); - tt_str_op(entry_stats_2,==, s); + tt_str_op(entry_stats_2,OP_EQ, s); tor_free(s);

/* Stop collecting entry statistics. */ @@ -1083,7 +1083,7 @@ test_geoip_with_pt(void *arg) /* Test the transport history string. */ s = geoip_get_transport_history(); tor_assert(s); - tt_str_op(s,==, "<OR>=8,alpha=16,beta=8,charlie=16,ddr=136," + tt_str_op(s,OP_EQ, "<OR>=8,alpha=16,beta=8,charlie=16,ddr=136," "entropy=8,fire=8,google=8");

/* Stop collecting entry statistics. */ @@ -1126,7 +1126,7 @@ test_stats(void *arg) tt_str_op("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n" "exit-kibibytes-written 80=1,443=1,other=0\n" "exit-kibibytes-read 80=10,443=20,other=0\n" - "exit-streams-opened 80=4,443=4,other=0\n",==, s); + "exit-streams-opened 80=4,443=4,other=0\n",OP_EQ, s); tor_free(s);

/* Add a few bytes on 10 more ports and ensure that only the top 10 @@ -1142,7 +1142,7 @@ test_stats(void *arg) "exit-kibibytes-read 52=1,53=1,54=1,55=1,56=1,57=1,58=1," "59=1,80=10,443=20,other=1\n" "exit-streams-opened 52=4,53=4,54=4,55=4,56=4,57=4,58=4," - "59=4,80=4,443=4,other=4\n",==, s); + "59=4,80=4,443=4,other=4\n",OP_EQ, s); tor_free(s);

/* Stop collecting stats, add some bytes, and ensure we don't generate @@ -1162,7 +1162,7 @@ test_stats(void *arg) tt_str_op("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n" "exit-kibibytes-written other=0\n" "exit-kibibytes-read other=0\n" - "exit-streams-opened other=0\n",==, s); + "exit-streams-opened other=0\n",OP_EQ, s); tor_free(s);

/* Continue with testing connection statistics; we shouldn't collect @@ -1178,7 +1178,7 @@ test_stats(void *arg) rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 10); rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 15); s = rep_hist_format_conn_stats(now + 86400); - tt_str_op("conn-bi-direct 2010-08-12 13:27:30 (86400 s) 0,0,1,0\n",==, s); + tt_str_op("conn-bi-direct 2010-08-12 13:27:30 (86400 s) 0,0,1,0\n",OP_EQ, s); tor_free(s);

/* Stop collecting stats, add some bytes, and ensure we don't generate @@ -1197,7 +1197,7 @@ test_stats(void *arg) rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 15); rep_hist_reset_conn_stats(now); s = rep_hist_format_conn_stats(now + 86400); - tt_str_op("conn-bi-direct 2010-08-12 13:27:30 (86400 s) 0,0,0,0\n",==, s); + tt_str_op("conn-bi-direct 2010-08-12 13:27:30 (86400 s) 0,0,0,0\n",OP_EQ, s); tor_free(s);

/* Continue with testing buffer statistics; we shouldn't collect buffer @@ -1216,7 +1216,7 @@ test_stats(void *arg) "cell-queued-cells 2.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00," "0.00,0.00\n" "cell-time-in-queue 2,0,0,0,0,0,0,0,0,0\n" - "cell-circuits-per-decile 1\n",==, s); + "cell-circuits-per-decile 1\n",OP_EQ, s); tor_free(s);

/* Add nineteen more circuit statistics to the one that's already in the @@ -1231,7 +1231,7 @@ test_stats(void *arg) "cell-queued-cells 2.75,2.75,2.75,2.75,2.75,2.75,2.75,2.75," "2.75,2.75\n" "cell-time-in-queue 3,3,3,3,3,3,3,3,3,3\n" - "cell-circuits-per-decile 2\n",==, s); + "cell-circuits-per-decile 2\n",OP_EQ, s); tor_free(s);

/* Stop collecting stats, add statistics for one circuit, and ensure we @@ -1252,7 +1252,7 @@ test_stats(void *arg) "cell-queued-cells 0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00," "0.00,0.00\n" "cell-time-in-queue 0,0,0,0,0,0,0,0,0,0\n" - "cell-circuits-per-decile 0\n",==, s); + "cell-circuits-per-decile 0\n",OP_EQ, s);

done: tor_free(s); diff --git a/src/test/test.h b/src/test/test.h index db07e4b..5518ca3 100644 --- a/src/test/test.h +++ b/src/test/test.h @@ -34,7 +34,7 @@ tt_mem_op(expr1, op, mem_op_hex_tmp, length/2); \ STMT_END

-#define test_memeq_hex(expr1, hex) test_mem_op_hex(expr1, ==, hex) +#define test_memeq_hex(expr1, hex) test_mem_op_hex(expr1, OP_EQ, hex)

#define tt_double_op(a,op,b) \ tt_assert_test_type(a,b,#a" "#op" "#b,double,(val1_ op val2_),"%f", \ diff --git a/src/test/test_addr.c b/src/test/test_addr.c index e9fe303..b7fe2c4 100644 --- a/src/test/test_addr.c +++ b/src/test/test_addr.c @@ -20,40 +20,40 @@ test_addr_basic(void *arg) (void)arg; cp = NULL; u32 = 3; u16 = 3; tt_assert(!addr_port_lookup(LOG_WARN, "1.2.3.4", &cp, &u32, &u16)); - tt_str_op(cp,==, "1.2.3.4"); - tt_int_op(u32,==, 0x01020304u); - tt_int_op(u16,==, 0); + tt_str_op(cp,OP_EQ, "1.2.3.4"); + tt_int_op(u32,OP_EQ, 0x01020304u); + tt_int_op(u16,OP_EQ, 0); tor_free(cp); tt_assert(!addr_port_lookup(LOG_WARN, "4.3.2.1:99", &cp, &u32, &u16)); - tt_str_op(cp,==, "4.3.2.1"); - tt_int_op(u32,==, 0x04030201u); - tt_int_op(u16,==, 99); + tt_str_op(cp,OP_EQ, "4.3.2.1"); + tt_int_op(u32,OP_EQ, 0x04030201u); + tt_int_op(u16,OP_EQ, 99); tor_free(cp); tt_assert(!addr_port_lookup(LOG_WARN, "nonexistent.address:4040", &cp, NULL, &u16)); - tt_str_op(cp,==, "nonexistent.address"); - tt_int_op(u16,==, 4040); + tt_str_op(cp,OP_EQ, "nonexistent.address"); + tt_int_op(u16,OP_EQ, 4040); tor_free(cp); tt_assert(!addr_port_lookup(LOG_WARN, "localhost:9999", &cp, &u32, &u16)); - tt_str_op(cp,==, "localhost"); - tt_int_op(u32,==, 0x7f000001u); - tt_int_op(u16,==, 9999); + tt_str_op(cp,OP_EQ, "localhost"); + tt_int_op(u32,OP_EQ, 0x7f000001u); + tt_int_op(u16,OP_EQ, 9999); tor_free(cp); u32 = 3; tt_assert(!addr_port_lookup(LOG_WARN, "localhost", NULL, &u32, &u16)); - tt_ptr_op(cp,==, NULL); - tt_int_op(u32,==, 0x7f000001u); - tt_int_op(u16,==, 0); + tt_ptr_op(cp,OP_EQ, NULL); + tt_int_op(u32,OP_EQ, 0x7f000001u); + tt_int_op(u16,OP_EQ, 0); tor_free(cp);

tt_assert(addr_port_lookup(LOG_WARN, "localhost:3", &cp, &u32, NULL)); tor_free(cp);

- tt_int_op(0,==, addr_mask_get_bits(0x0u)); - tt_int_op(32,==, addr_mask_get_bits(0xFFFFFFFFu)); - tt_int_op(16,==, addr_mask_get_bits(0xFFFF0000u)); - tt_int_op(31,==, addr_mask_get_bits(0xFFFFFFFEu)); - tt_int_op(1,==, addr_mask_get_bits(0x80000000u)); + tt_int_op(0,OP_EQ, addr_mask_get_bits(0x0u)); + tt_int_op(32,OP_EQ, addr_mask_get_bits(0xFFFFFFFFu)); + tt_int_op(16,OP_EQ, addr_mask_get_bits(0xFFFF0000u)); + tt_int_op(31,OP_EQ, addr_mask_get_bits(0xFFFFFFFEu)); + tt_int_op(1,OP_EQ, addr_mask_get_bits(0x80000000u));

/* Test inet_ntop */ { @@ -62,15 +62,15 @@ test_addr_basic(void *arg) struct in_addr in;

/* good round trip */ - tt_int_op(tor_inet_pton(AF_INET, ip, &in),==, 1); - tt_ptr_op(tor_inet_ntop(AF_INET, &in, tmpbuf, sizeof(tmpbuf)),==, &tmpbuf); - tt_str_op(tmpbuf,==, ip); + tt_int_op(tor_inet_pton(AF_INET, ip, &in),OP_EQ, 1); + tt_ptr_op(tor_inet_ntop(AF_INET, &in, tmpbuf, sizeof(tmpbuf)),OP_EQ, &tmpbuf); + tt_str_op(tmpbuf,OP_EQ, ip);

/* just enough buffer length */ - tt_str_op(tor_inet_ntop(AF_INET, &in, tmpbuf, strlen(ip) + 1),==, ip); + tt_str_op(tor_inet_ntop(AF_INET, &in, tmpbuf, strlen(ip) + 1),OP_EQ, ip);

/* too short buffer */ - tt_ptr_op(tor_inet_ntop(AF_INET, &in, tmpbuf, strlen(ip)),==, NULL); + tt_ptr_op(tor_inet_ntop(AF_INET, &in, tmpbuf, strlen(ip)),OP_EQ, NULL); }

done: @@ -98,30 +98,30 @@ test_addr_basic(void *arg) /** Helper: Assert that two strings both decode as IPv6 addresses with * tor_inet_pton(), and both decode to the same address. */ #define test_pton6_same(a,b) STMT_BEGIN \ - tt_int_op(tor_inet_pton(AF_INET6, a, &a1), ==, 1); \ - tt_int_op(tor_inet_pton(AF_INET6, b, &a2), ==, 1); \ - test_op_ip6_(&a1,==,&a2,#a,#b); \ + tt_int_op(tor_inet_pton(AF_INET6, a, &a1), OP_EQ, 1); \ + tt_int_op(tor_inet_pton(AF_INET6, b, &a2), OP_EQ, 1); \ + test_op_ip6_(&a1,OP_EQ,&a2,#a,#b); \ STMT_END

/** Helper: Assert that <b>a</b> is recognized as a bad IPv6 address by * tor_inet_pton(). */ #define test_pton6_bad(a) \ - tt_int_op(0, ==, tor_inet_pton(AF_INET6, a, &a1)) + tt_int_op(0, OP_EQ, tor_inet_pton(AF_INET6, a, &a1))

/** Helper: assert that <b>a</b>, when parsed by tor_inet_pton() and displayed * with tor_inet_ntop(), yields <b>b</b>. Also assert that <b>b</b> parses to * the same value as <b>a</b>. */ #define test_ntop6_reduces(a,b) STMT_BEGIN \ - tt_int_op(tor_inet_pton(AF_INET6, a, &a1), ==, 1); \ - tt_str_op(tor_inet_ntop(AF_INET6, &a1, buf, sizeof(buf)), ==, b); \ - tt_int_op(tor_inet_pton(AF_INET6, b, &a2), ==, 1); \ - test_op_ip6_(&a1, ==, &a2, a, b); \ + tt_int_op(tor_inet_pton(AF_INET6, a, &a1), OP_EQ, 1); \ + tt_str_op(tor_inet_ntop(AF_INET6, &a1, buf, sizeof(buf)), OP_EQ, b); \ + tt_int_op(tor_inet_pton(AF_INET6, b, &a2), OP_EQ, 1); \ + test_op_ip6_(&a1, OP_EQ, &a2, a, b); \ STMT_END

/** Helper: assert that <b>a</b> parses by tor_inet_pton() into a address that * passes tor_addr_is_internal() with <b>for_listening</b>. */ #define test_internal_ip(a,for_listening) STMT_BEGIN \ - tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), ==, 1); \ + tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), OP_EQ, 1); \ t1.family = AF_INET6; \ if (!tor_addr_is_internal(&t1, for_listening)) \ TT_DIE(("%s was not internal", a)); \ @@ -130,7 +130,7 @@ test_addr_basic(void *arg) /** Helper: assert that <b>a</b> parses by tor_inet_pton() into a address that * does not pass tor_addr_is_internal() with <b>for_listening</b>. */ #define test_external_ip(a,for_listening) STMT_BEGIN \ - tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), ==, 1); \ + tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), OP_EQ, 1); \ t1.family = AF_INET6; \ if (tor_addr_is_internal(&t1, for_listening)) \ TT_DIE(("%s was not internal", a)); \ @@ -140,8 +140,8 @@ test_addr_basic(void *arg) * tor_inet_pton(), give addresses that compare in the order defined by * <b>op</b> with tor_addr_compare(). */ #define test_addr_compare(a, op, b) STMT_BEGIN \ - tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), ==, 1); \ - tt_int_op(tor_inet_pton(AF_INET6, b, &t2.addr.in6_addr), ==, 1); \ + tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), OP_EQ, 1); \ + tt_int_op(tor_inet_pton(AF_INET6, b, &t2.addr.in6_addr), OP_EQ, 1); \ t1.family = t2.family = AF_INET6; \ r = tor_addr_compare(&t1,&t2,CMP_SEMANTIC); \ if (!(r op 0)) \ @@ -152,8 +152,8 @@ test_addr_basic(void *arg) * tor_inet_pton(), give addresses that compare in the order defined by * <b>op</b> with tor_addr_compare_masked() with <b>m</b> masked. */ #define test_addr_compare_masked(a, op, b, m) STMT_BEGIN \ - tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), ==, 1); \ - tt_int_op(tor_inet_pton(AF_INET6, b, &t2.addr.in6_addr), ==, 1); \ + tt_int_op(tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr), OP_EQ, 1); \ + tt_int_op(tor_inet_pton(AF_INET6, b, &t2.addr.in6_addr), OP_EQ, 1); \ t1.family = t2.family = AF_INET6; \ r = tor_addr_compare_masked(&t1,&t2,m,CMP_SEMANTIC); \ if (!(r op 0)) \ @@ -168,15 +168,15 @@ test_addr_basic(void *arg) #define test_addr_mask_ports_parse(xx, f, ip1, ip2, ip3, ip4, mm, pt1, pt2) \ STMT_BEGIN \ tt_int_op(tor_addr_parse_mask_ports(xx, 0, &t1, &mask, &port1, &port2), \ - ==, f); \ + OP_EQ, f); \ p1=tor_inet_ntop(AF_INET6, &t1.addr.in6_addr, bug, sizeof(bug)); \ - tt_int_op(htonl(ip1), ==, tor_addr_to_in6_addr32(&t1)[0]); \ - tt_int_op(htonl(ip2), ==, tor_addr_to_in6_addr32(&t1)[1]); \ - tt_int_op(htonl(ip3), ==, tor_addr_to_in6_addr32(&t1)[2]); \ - tt_int_op(htonl(ip4), ==, tor_addr_to_in6_addr32(&t1)[3]); \ - tt_int_op(mask, ==, mm); \ - tt_uint_op(port1, ==, pt1); \ - tt_uint_op(port2, ==, pt2); \ + tt_int_op(htonl(ip1), OP_EQ, tor_addr_to_in6_addr32(&t1)[0]); \ + tt_int_op(htonl(ip2), OP_EQ, tor_addr_to_in6_addr32(&t1)[1]); \ + tt_int_op(htonl(ip3), OP_EQ, tor_addr_to_in6_addr32(&t1)[2]); \ + tt_int_op(htonl(ip4), OP_EQ, tor_addr_to_in6_addr32(&t1)[3]); \ + tt_int_op(mask, OP_EQ, mm); \ + tt_uint_op(port1, OP_EQ, pt1); \ + tt_uint_op(port2, OP_EQ, pt2); \ STMT_END

/** Run unit tests for IPv6 encoding/decoding/manipulation functions. */ @@ -202,23 +202,23 @@ test_addr_ip6_helpers(void *arg) const char *ip_ffff = "::ffff:192.168.1.2";

/* good round trip */ - tt_int_op(tor_inet_pton(AF_INET6, ip, &a1),==, 1); - tt_ptr_op(tor_inet_ntop(AF_INET6, &a1, buf, sizeof(buf)),==, &buf); - tt_str_op(buf,==, ip); + tt_int_op(tor_inet_pton(AF_INET6, ip, &a1),OP_EQ, 1); + tt_ptr_op(tor_inet_ntop(AF_INET6, &a1, buf, sizeof(buf)),OP_EQ, &buf); + tt_str_op(buf,OP_EQ, ip);

/* good round trip - ::ffff:0:0 style */ - tt_int_op(tor_inet_pton(AF_INET6, ip_ffff, &a2),==, 1); - tt_ptr_op(tor_inet_ntop(AF_INET6, &a2, buf, sizeof(buf)),==, &buf); - tt_str_op(buf,==, ip_ffff); + tt_int_op(tor_inet_pton(AF_INET6, ip_ffff, &a2),OP_EQ, 1); + tt_ptr_op(tor_inet_ntop(AF_INET6, &a2, buf, sizeof(buf)),OP_EQ, &buf); + tt_str_op(buf,OP_EQ, ip_ffff);

/* just long enough buffer (remember \0) */ - tt_str_op(tor_inet_ntop(AF_INET6, &a1, buf, strlen(ip)+1),==, ip); - tt_str_op(tor_inet_ntop(AF_INET6, &a2, buf, strlen(ip_ffff)+1),==, + tt_str_op(tor_inet_ntop(AF_INET6, &a1, buf, strlen(ip)+1),OP_EQ, ip); + tt_str_op(tor_inet_ntop(AF_INET6, &a2, buf, strlen(ip_ffff)+1),OP_EQ, ip_ffff);

/* too short buffer (remember \0) */ - tt_ptr_op(tor_inet_ntop(AF_INET6, &a1, buf, strlen(ip)),==, NULL); - tt_ptr_op(tor_inet_ntop(AF_INET6, &a2, buf, strlen(ip_ffff)),==, NULL); + tt_ptr_op(tor_inet_ntop(AF_INET6, &a1, buf, strlen(ip)),OP_EQ, NULL); + tt_ptr_op(tor_inet_ntop(AF_INET6, &a2, buf, strlen(ip_ffff)),OP_EQ, NULL); }

/* ==== Converting to and from sockaddr_t. */ @@ -227,16 +227,16 @@ test_addr_ip6_helpers(void *arg) sin->sin_port = htons(9090); sin->sin_addr.s_addr = htonl(0x7f7f0102); /*127.127.1.2*/ tor_addr_from_sockaddr(&t1, (struct sockaddr *)sin, &port1); - tt_int_op(tor_addr_family(&t1),==, AF_INET); - tt_int_op(tor_addr_to_ipv4h(&t1),==, 0x7f7f0102); - tt_int_op(port1, ==, 9090); + tt_int_op(tor_addr_family(&t1),OP_EQ, AF_INET); + tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ, 0x7f7f0102); + tt_int_op(port1, OP_EQ, 9090);

memset(&sa_storage, 0, sizeof(sa_storage)); - tt_int_op(sizeof(struct sockaddr_in),==, + tt_int_op(sizeof(struct sockaddr_in),OP_EQ, tor_addr_to_sockaddr(&t1, 1234, (struct sockaddr *)&sa_storage, sizeof(sa_storage))); - tt_int_op(1234,==, ntohs(sin->sin_port)); - tt_int_op(0x7f7f0102,==, ntohl(sin->sin_addr.s_addr)); + tt_int_op(1234,OP_EQ, ntohs(sin->sin_port)); + tt_int_op(0x7f7f0102,OP_EQ, ntohl(sin->sin_addr.s_addr));

memset(&sa_storage, 0, sizeof(sa_storage)); sin6 = (struct sockaddr_in6 *)&sa_storage; @@ -244,37 +244,37 @@ test_addr_ip6_helpers(void *arg) sin6->sin6_port = htons(7070); sin6->sin6_addr.s6_addr[0] = 128; tor_addr_from_sockaddr(&t1, (struct sockaddr *)sin6, &port1); - tt_int_op(tor_addr_family(&t1),==, AF_INET6); - tt_int_op(port1, ==, 7070); + tt_int_op(tor_addr_family(&t1),OP_EQ, AF_INET6); + tt_int_op(port1, OP_EQ, 7070); p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 0); - tt_str_op(p1,==, "8000::"); + tt_str_op(p1,OP_EQ, "8000::");

memset(&sa_storage, 0, sizeof(sa_storage)); - tt_int_op(sizeof(struct sockaddr_in6),==, + tt_int_op(sizeof(struct sockaddr_in6),OP_EQ, tor_addr_to_sockaddr(&t1, 9999, (struct sockaddr *)&sa_storage, sizeof(sa_storage))); - tt_int_op(AF_INET6,==, sin6->sin6_family); - tt_int_op(9999,==, ntohs(sin6->sin6_port)); - tt_int_op(0x80000000,==, ntohl(S6_ADDR32(sin6->sin6_addr)[0])); + tt_int_op(AF_INET6,OP_EQ, sin6->sin6_family); + tt_int_op(9999,OP_EQ, ntohs(sin6->sin6_port)); + tt_int_op(0x80000000,OP_EQ, ntohl(S6_ADDR32(sin6->sin6_addr)[0]));

/* ==== tor_addr_lookup: static cases. (Can't test dns without knowing we * have a good resolver. */ - tt_int_op(0,==, tor_addr_lookup("127.128.129.130", AF_UNSPEC, &t1)); - tt_int_op(AF_INET,==, tor_addr_family(&t1)); - tt_int_op(tor_addr_to_ipv4h(&t1),==, 0x7f808182); + tt_int_op(0,OP_EQ, tor_addr_lookup("127.128.129.130", AF_UNSPEC, &t1)); + tt_int_op(AF_INET,OP_EQ, tor_addr_family(&t1)); + tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ, 0x7f808182);

- tt_int_op(0,==, tor_addr_lookup("9000::5", AF_UNSPEC, &t1)); - tt_int_op(AF_INET6,==, tor_addr_family(&t1)); - tt_int_op(0x90,==, tor_addr_to_in6_addr8(&t1)[0]); + tt_int_op(0,OP_EQ, tor_addr_lookup("9000::5", AF_UNSPEC, &t1)); + tt_int_op(AF_INET6,OP_EQ, tor_addr_family(&t1)); + tt_int_op(0x90,OP_EQ, tor_addr_to_in6_addr8(&t1)[0]); tt_assert(tor_mem_is_zero((char*)tor_addr_to_in6_addr8(&t1)+1, 14)); - tt_int_op(0x05,==, tor_addr_to_in6_addr8(&t1)[15]); + tt_int_op(0x05,OP_EQ, tor_addr_to_in6_addr8(&t1)[15]);

/* === Test pton: valid af_inet6 */ /* Simple, valid parsing. */ r = tor_inet_pton(AF_INET6, "0102:0304:0506:0708:090A:0B0C:0D0E:0F10", &a1); - tt_int_op(r, ==, 1); - for (i=0;i<16;++i) { tt_int_op(i+1,==, (int)a1.s6_addr[i]); } + tt_int_op(r, OP_EQ, 1); + for (i=0;i<16;++i) { tt_int_op(i+1,OP_EQ, (int)a1.s6_addr[i]); } /* ipv4 ending. */ test_pton6_same("0102:0304:0506:0708:090A:0B0C:0D0E:0F10", "0102:0304:0506:0708:090A:0B0C:13.14.15.16"); @@ -314,7 +314,7 @@ test_addr_ip6_helpers(void *arg) "1000:1:0:7::");

/* Bad af param */ - tt_int_op(tor_inet_pton(AF_UNSPEC, 0, 0),==, -1); + tt_int_op(tor_inet_pton(AF_UNSPEC, 0, 0),OP_EQ, -1);

/* === Test pton: invalid in6. */ test_pton6_bad("foobar."); @@ -410,11 +410,11 @@ test_addr_ip6_helpers(void *arg) test_external_ip("::ffff:169.255.0.0", 0);

/* tor_addr_compare(tor_addr_t x2) */ - test_addr_compare("ffff::", ==, "ffff::0"); - test_addr_compare("0::3:2:1", <, "0::ffff:0.3.2.1"); - test_addr_compare("0::2:2:1", <, "0::ffff:0.3.2.1"); - test_addr_compare("0::ffff:0.3.2.1", >, "0::0:0:0"); - test_addr_compare("0::ffff:5.2.2.1", <, "::ffff:6.0.0.0"); /* XXXX wrong. */ + test_addr_compare("ffff::", OP_EQ, "ffff::0"); + test_addr_compare("0::3:2:1", OP_LT, "0::ffff:0.3.2.1"); + test_addr_compare("0::2:2:1", OP_LT, "0::ffff:0.3.2.1"); + test_addr_compare("0::ffff:0.3.2.1", OP_GT, "0::0:0:0"); + test_addr_compare("0::ffff:5.2.2.1", OP_LT, "::ffff:6.0.0.0"); /* XXXX wrong. */ tor_addr_parse_mask_ports("[::ffff:2.3.4.5]", 0, &t1, NULL, NULL, NULL); tor_addr_parse_mask_ports("2.3.4.5", 0, &t2, NULL, NULL, NULL); tt_assert(tor_addr_compare(&t1, &t2, CMP_SEMANTIC) == 0); @@ -423,119 +423,119 @@ test_addr_ip6_helpers(void *arg) tt_assert(tor_addr_compare(&t1, &t2, CMP_SEMANTIC) < 0);

/* test compare_masked */ - test_addr_compare_masked("ffff::", ==, "ffff::0", 128); - test_addr_compare_masked("ffff::", ==, "ffff::0", 64); - test_addr_compare_masked("0::2:2:1", <, "0::8000:2:1", 81); - test_addr_compare_masked("0::2:2:1", ==, "0::8000:2:1", 80); + test_addr_compare_masked("ffff::", OP_EQ, "ffff::0", 128); + test_addr_compare_masked("ffff::", OP_EQ, "ffff::0", 64); + test_addr_compare_masked("0::2:2:1", OP_LT, "0::8000:2:1", 81); + test_addr_compare_masked("0::2:2:1", OP_EQ, "0::8000:2:1", 80);

/* Test undecorated tor_addr_to_str */ - tt_int_op(AF_INET6,==, tor_addr_parse(&t1, "[123:45:6789::5005:11]")); + tt_int_op(AF_INET6,OP_EQ, tor_addr_parse(&t1, "[123:45:6789::5005:11]")); p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 0); - tt_str_op(p1,==, "123:45:6789::5005:11"); - tt_int_op(AF_INET,==, tor_addr_parse(&t1, "18.0.0.1")); + tt_str_op(p1,OP_EQ, "123:45:6789::5005:11"); + tt_int_op(AF_INET,OP_EQ, tor_addr_parse(&t1, "18.0.0.1")); p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 0); - tt_str_op(p1,==, "18.0.0.1"); + tt_str_op(p1,OP_EQ, "18.0.0.1");

/* Test decorated tor_addr_to_str */ - tt_int_op(AF_INET6,==, tor_addr_parse(&t1, "[123:45:6789::5005:11]")); + tt_int_op(AF_INET6,OP_EQ, tor_addr_parse(&t1, "[123:45:6789::5005:11]")); p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1); - tt_str_op(p1,==, "[123:45:6789::5005:11]"); - tt_int_op(AF_INET,==, tor_addr_parse(&t1, "18.0.0.1")); + tt_str_op(p1,OP_EQ, "[123:45:6789::5005:11]"); + tt_int_op(AF_INET,OP_EQ, tor_addr_parse(&t1, "18.0.0.1")); p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1); - tt_str_op(p1,==, "18.0.0.1"); + tt_str_op(p1,OP_EQ, "18.0.0.1");

/* Test buffer bounds checking of tor_addr_to_str */ - tt_int_op(AF_INET6,==, tor_addr_parse(&t1, "::")); /* 2 + \0 */ - tt_ptr_op(tor_addr_to_str(buf, &t1, 2, 0),==, NULL); /* too short buf */ - tt_str_op(tor_addr_to_str(buf, &t1, 3, 0),==, "::"); - tt_ptr_op(tor_addr_to_str(buf, &t1, 4, 1),==, NULL); /* too short buf */ - tt_str_op(tor_addr_to_str(buf, &t1, 5, 1),==, "[::]"); - - tt_int_op(AF_INET6,==, tor_addr_parse(&t1, "2000::1337")); /* 10 + \0 */ - tt_ptr_op(tor_addr_to_str(buf, &t1, 10, 0),==, NULL); /* too short buf */ - tt_str_op(tor_addr_to_str(buf, &t1, 11, 0),==, "2000::1337"); - tt_ptr_op(tor_addr_to_str(buf, &t1, 12, 1),==, NULL); /* too short buf */ - tt_str_op(tor_addr_to_str(buf, &t1, 13, 1),==, "[2000::1337]"); - - tt_int_op(AF_INET,==, tor_addr_parse(&t1, "1.2.3.4")); /* 7 + \0 */ - tt_ptr_op(tor_addr_to_str(buf, &t1, 7, 0),==, NULL); /* too short buf */ - tt_str_op(tor_addr_to_str(buf, &t1, 8, 0),==, "1.2.3.4"); - - tt_int_op(AF_INET,==, tor_addr_parse(&t1, "255.255.255.255")); /* 15 + \0 */ - tt_ptr_op(tor_addr_to_str(buf, &t1, 15, 0),==, NULL); /* too short buf */ - tt_str_op(tor_addr_to_str(buf, &t1, 16, 0),==, "255.255.255.255"); - tt_ptr_op(tor_addr_to_str(buf, &t1, 15, 1),==, NULL); /* too short buf */ - tt_str_op(tor_addr_to_str(buf, &t1, 16, 1),==, "255.255.255.255"); + tt_int_op(AF_INET6,OP_EQ, tor_addr_parse(&t1, "::")); /* 2 + \0 */ + tt_ptr_op(tor_addr_to_str(buf, &t1, 2, 0),OP_EQ, NULL); /* too short buf */ + tt_str_op(tor_addr_to_str(buf, &t1, 3, 0),OP_EQ, "::"); + tt_ptr_op(tor_addr_to_str(buf, &t1, 4, 1),OP_EQ, NULL); /* too short buf */ + tt_str_op(tor_addr_to_str(buf, &t1, 5, 1),OP_EQ, "[::]"); + + tt_int_op(AF_INET6,OP_EQ, tor_addr_parse(&t1, "2000::1337")); /* 10 + \0 */ + tt_ptr_op(tor_addr_to_str(buf, &t1, 10, 0),OP_EQ, NULL); /* too short buf */ + tt_str_op(tor_addr_to_str(buf, &t1, 11, 0),OP_EQ, "2000::1337"); + tt_ptr_op(tor_addr_to_str(buf, &t1, 12, 1),OP_EQ, NULL); /* too short buf */ + tt_str_op(tor_addr_to_str(buf, &t1, 13, 1),OP_EQ, "[2000::1337]"); + + tt_int_op(AF_INET,OP_EQ, tor_addr_parse(&t1, "1.2.3.4")); /* 7 + \0 */ + tt_ptr_op(tor_addr_to_str(buf, &t1, 7, 0),OP_EQ, NULL); /* too short buf */ + tt_str_op(tor_addr_to_str(buf, &t1, 8, 0),OP_EQ, "1.2.3.4"); + + tt_int_op(AF_INET,OP_EQ, tor_addr_parse(&t1, "255.255.255.255")); /* 15 + \0 */ + tt_ptr_op(tor_addr_to_str(buf, &t1, 15, 0),OP_EQ, NULL); /* too short buf */ + tt_str_op(tor_addr_to_str(buf, &t1, 16, 0),OP_EQ, "255.255.255.255"); + tt_ptr_op(tor_addr_to_str(buf, &t1, 15, 1),OP_EQ, NULL); /* too short buf */ + tt_str_op(tor_addr_to_str(buf, &t1, 16, 1),OP_EQ, "255.255.255.255");

t1.family = AF_UNSPEC; - tt_ptr_op(tor_addr_to_str(buf, &t1, sizeof(buf), 0),==, NULL); + tt_ptr_op(tor_addr_to_str(buf, &t1, sizeof(buf), 0),OP_EQ, NULL);

/* Test tor_addr_parse_PTR_name */ i = tor_addr_parse_PTR_name(&t1, "Foobar.baz", AF_UNSPEC, 0); - tt_int_op(0,==, i); + tt_int_op(0,OP_EQ, i); i = tor_addr_parse_PTR_name(&t1, "Foobar.baz", AF_UNSPEC, 1); - tt_int_op(0,==, i); + tt_int_op(0,OP_EQ, i); i = tor_addr_parse_PTR_name(&t1, "9999999999999999999999999999.in-addr.arpa", AF_UNSPEC, 1); - tt_int_op(-1,==, i); + tt_int_op(-1,OP_EQ, i); i = tor_addr_parse_PTR_name(&t1, "1.0.168.192.in-addr.arpa", AF_UNSPEC, 1); - tt_int_op(1,==, i); - tt_int_op(tor_addr_family(&t1),==, AF_INET); + tt_int_op(1,OP_EQ, i); + tt_int_op(tor_addr_family(&t1),OP_EQ, AF_INET); p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1); - tt_str_op(p1,==, "192.168.0.1"); + tt_str_op(p1,OP_EQ, "192.168.0.1"); i = tor_addr_parse_PTR_name(&t1, "192.168.0.99", AF_UNSPEC, 0); - tt_int_op(0,==, i); + tt_int_op(0,OP_EQ, i); i = tor_addr_parse_PTR_name(&t1, "192.168.0.99", AF_UNSPEC, 1); - tt_int_op(1,==, i); + tt_int_op(1,OP_EQ, i); p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1); - tt_str_op(p1,==, "192.168.0.99"); + tt_str_op(p1,OP_EQ, "192.168.0.99"); memset(&t1, 0, sizeof(t1)); i = tor_addr_parse_PTR_name(&t1, "0.1.2.3.4.5.6.7.8.9.a.b.c.d.e.f." "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9." "ip6.ARPA", AF_UNSPEC, 0); - tt_int_op(1,==, i); + tt_int_op(1,OP_EQ, i); p1 = tor_addr_to_str(buf, &t1, sizeof(buf), 1); - tt_str_op(p1,==, "[9dee:effe:ebe1:beef:fedc:ba98:7654:3210]"); + tt_str_op(p1,OP_EQ, "[9dee:effe:ebe1:beef:fedc:ba98:7654:3210]"); /* Failing cases. */ i = tor_addr_parse_PTR_name(&t1, "6.7.8.9.a.b.c.d.e.f." "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9." "ip6.ARPA", AF_UNSPEC, 0); - tt_int_op(i,==, -1); + tt_int_op(i,OP_EQ, -1); i = tor_addr_parse_PTR_name(&t1, "6.7.8.9.a.b.c.d.e.f.a.b.c.d.e.f.0." "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9." "ip6.ARPA", AF_UNSPEC, 0); - tt_int_op(i,==, -1); + tt_int_op(i,OP_EQ, -1); i = tor_addr_parse_PTR_name(&t1, "6.7.8.9.a.b.c.d.e.f.X.0.0.0.0.9." "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9." "ip6.ARPA", AF_UNSPEC, 0); - tt_int_op(i,==, -1); + tt_int_op(i,OP_EQ, -1); i = tor_addr_parse_PTR_name(&t1, "32.1.1.in-addr.arpa", AF_UNSPEC, 0); - tt_int_op(i,==, -1); + tt_int_op(i,OP_EQ, -1); i = tor_addr_parse_PTR_name(&t1, ".in-addr.arpa", AF_UNSPEC, 0); - tt_int_op(i,==, -1); + tt_int_op(i,OP_EQ, -1); i = tor_addr_parse_PTR_name(&t1, "1.2.3.4.5.in-addr.arpa", AF_UNSPEC, 0); - tt_int_op(i,==, -1); + tt_int_op(i,OP_EQ, -1); i = tor_addr_parse_PTR_name(&t1, "1.2.3.4.5.in-addr.arpa", AF_INET6, 0); - tt_int_op(i,==, -1); + tt_int_op(i,OP_EQ, -1); i = tor_addr_parse_PTR_name(&t1, "6.7.8.9.a.b.c.d.e.f.a.b.c.d.e.0." "f.e.e.b.1.e.b.e.e.f.f.e.e.e.d.9." "ip6.ARPA", AF_INET, 0); - tt_int_op(i,==, -1); + tt_int_op(i,OP_EQ, -1);

/* === Test tor_addr_to_PTR_name */

@@ -547,19 +547,19 @@ test_addr_ip6_helpers(void *arg) tor_addr_from_sockaddr(&t1, (struct sockaddr *)sin, NULL);

/* Check IPv4 PTR - too short buffer */ - tt_int_op(tor_addr_to_PTR_name(rbuf, 1, &t1),==, -1); + tt_int_op(tor_addr_to_PTR_name(rbuf, 1, &t1),OP_EQ, -1); tt_int_op(tor_addr_to_PTR_name(rbuf, strlen("3.2.1.127.in-addr.arpa") - 1, - &t1),==, -1); + &t1),OP_EQ, -1);

/* Check IPv4 PTR - valid addr */ - tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),==, + tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),OP_EQ, strlen("3.2.1.127.in-addr.arpa")); - tt_str_op(rbuf,==, "3.2.1.127.in-addr.arpa"); + tt_str_op(rbuf,OP_EQ, "3.2.1.127.in-addr.arpa");

/* Invalid addr family */ t1.family = AF_UNSPEC; - tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),==, -1); + tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),OP_EQ, -1);

/* Stage IPv6 addr */ memset(&sa_storage, 0, sizeof(sa_storage)); @@ -576,81 +576,81 @@ test_addr_ip6_helpers(void *arg) "0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.ip6.arpa";

/* Check IPv6 PTR - too short buffer */ - tt_int_op(tor_addr_to_PTR_name(rbuf, 0, &t1),==, -1); - tt_int_op(tor_addr_to_PTR_name(rbuf, strlen(addr_PTR) - 1, &t1),==, -1); + tt_int_op(tor_addr_to_PTR_name(rbuf, 0, &t1),OP_EQ, -1); + tt_int_op(tor_addr_to_PTR_name(rbuf, strlen(addr_PTR) - 1, &t1),OP_EQ, -1);

/* Check IPv6 PTR - valid addr */ - tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),==, + tt_int_op(tor_addr_to_PTR_name(rbuf, sizeof(rbuf), &t1),OP_EQ, strlen(addr_PTR)); - tt_str_op(rbuf,==, addr_PTR); + tt_str_op(rbuf,OP_EQ, addr_PTR); }

/* XXXX turn this into a separate function; it's not all IPv6. */ /* test tor_addr_parse_mask_ports */ test_addr_mask_ports_parse("[::f]/17:47-95", AF_INET6, 0, 0, 0, 0x0000000f, 17, 47, 95); - tt_str_op(p1,==, "::f"); + tt_str_op(p1,OP_EQ, "::f"); //test_addr_parse("[::fefe:4.1.1.7/120]:999-1000"); //test_addr_parse_check("::fefe:401:107", 120, 999, 1000); test_addr_mask_ports_parse("[::ffff:4.1.1.7]/120:443", AF_INET6, 0, 0, 0x0000ffff, 0x04010107, 120, 443, 443); - tt_str_op(p1,==, "::ffff:4.1.1.7"); + tt_str_op(p1,OP_EQ, "::ffff:4.1.1.7"); test_addr_mask_ports_parse("[abcd:2::44a:0]:2-65000", AF_INET6, 0xabcd0002, 0, 0, 0x044a0000, 128, 2, 65000);

- tt_str_op(p1,==, "abcd:2::44a:0"); + tt_str_op(p1,OP_EQ, "abcd:2::44a:0"); /* Try some long addresses. */ r=tor_addr_parse_mask_ports("[ffff:1111:1111:1111:1111:1111:1111:1111]", 0, &t1, NULL, NULL, NULL); tt_assert(r == AF_INET6); r=tor_addr_parse_mask_ports("[ffff:1111:1111:1111:1111:1111:1111:11111]", 0, &t1, NULL, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); r=tor_addr_parse_mask_ports("[ffff:1111:1111:1111:1111:1111:1111:1111:1]", 0, &t1, NULL, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); r=tor_addr_parse_mask_ports( "[ffff:1111:1111:1111:1111:1111:1111:ffff:" "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:" "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:" "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]", 0, &t1, NULL, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); /* Try some failing cases. */ r=tor_addr_parse_mask_ports("[fefef::]/112", 0, &t1, NULL, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); r=tor_addr_parse_mask_ports("[fefe::/112", 0, &t1, NULL, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); r=tor_addr_parse_mask_ports("[fefe::", 0, &t1, NULL, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); r=tor_addr_parse_mask_ports("[fefe::X]", 0, &t1, NULL, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); r=tor_addr_parse_mask_ports("efef::/112", 0, &t1, NULL, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); r=tor_addr_parse_mask_ports("[f:f:f:f:f:f:f:f::]",0,&t1, NULL, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); r=tor_addr_parse_mask_ports("[::f:f:f:f:f:f:f:f]",0,&t1, NULL, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); r=tor_addr_parse_mask_ports("[f:f:f:f:f:f:f:f:f]",0,&t1, NULL, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); r=tor_addr_parse_mask_ports("[f:f:f:f:f::]/fred",0,&t1,&mask, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); r=tor_addr_parse_mask_ports("[f:f:f:f:f::]/255.255.0.0", 0,&t1, NULL, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); /* This one will get rejected because it isn't a pure prefix. */ r=tor_addr_parse_mask_ports("1.1.2.3/255.255.64.0",0,&t1, &mask,NULL,NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); /* Test for V4-mapped address with mask < 96. (arguably not valid) */ r=tor_addr_parse_mask_ports("[::ffff:1.1.2.2/33]",0,&t1, &mask, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); r=tor_addr_parse_mask_ports("1.1.2.2/33",0,&t1, &mask, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); /* Try extended wildcard addresses with out TAPMP_EXTENDED_STAR*/ r=tor_addr_parse_mask_ports("*4",0,&t1, &mask, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); r=tor_addr_parse_mask_ports("*6",0,&t1, &mask, NULL, NULL); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); #if 0 /* Try a mask with a wildcard. */ r=tor_addr_parse_mask_ports("*/16",0,&t1, &mask, NULL, NULL); @@ -665,57 +665,57 @@ test_addr_ip6_helpers(void *arg) /* Basic mask tests*/ r=tor_addr_parse_mask_ports("1.1.2.2/31",0,&t1, &mask, NULL, NULL); tt_assert(r == AF_INET); - tt_int_op(mask,==,31); - tt_int_op(tor_addr_family(&t1),==,AF_INET); - tt_int_op(tor_addr_to_ipv4h(&t1),==,0x01010202); + tt_int_op(mask,OP_EQ,31); + tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET); + tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ,0x01010202); r=tor_addr_parse_mask_ports("3.4.16.032:1-2",0,&t1, &mask, &port1, &port2); tt_assert(r == AF_INET); - tt_int_op(mask,==,32); - tt_int_op(tor_addr_family(&t1),==,AF_INET); - tt_int_op(tor_addr_to_ipv4h(&t1),==,0x03041020); + tt_int_op(mask,OP_EQ,32); + tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET); + tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ,0x03041020); tt_assert(port1 == 1); tt_assert(port2 == 2); r=tor_addr_parse_mask_ports("1.1.2.3/255.255.128.0",0,&t1, &mask,NULL,NULL); tt_assert(r == AF_INET); - tt_int_op(mask,==,17); - tt_int_op(tor_addr_family(&t1),==,AF_INET); - tt_int_op(tor_addr_to_ipv4h(&t1),==,0x01010203); + tt_int_op(mask,OP_EQ,17); + tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET); + tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ,0x01010203); r=tor_addr_parse_mask_ports("[efef::]/112",0,&t1, &mask, &port1, &port2); tt_assert(r == AF_INET6); tt_assert(port1 == 1); tt_assert(port2 == 65535); /* Try regular wildcard behavior without TAPMP_EXTENDED_STAR */ r=tor_addr_parse_mask_ports("*:80-443",0,&t1,&mask,&port1,&port2); - tt_int_op(r,==,AF_INET); /* Old users of this always get inet */ - tt_int_op(tor_addr_family(&t1),==,AF_INET); - tt_int_op(tor_addr_to_ipv4h(&t1),==,0); - tt_int_op(mask,==,0); - tt_int_op(port1,==,80); - tt_int_op(port2,==,443); + tt_int_op(r,OP_EQ,AF_INET); /* Old users of this always get inet */ + tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET); + tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ,0); + tt_int_op(mask,OP_EQ,0); + tt_int_op(port1,OP_EQ,80); + tt_int_op(port2,OP_EQ,443); /* Now try wildcards *with* TAPMP_EXTENDED_STAR */ r=tor_addr_parse_mask_ports("*:8000-9000",TAPMP_EXTENDED_STAR, &t1,&mask,&port1,&port2); - tt_int_op(r,==,AF_UNSPEC); - tt_int_op(tor_addr_family(&t1),==,AF_UNSPEC); - tt_int_op(mask,==,0); - tt_int_op(port1,==,8000); - tt_int_op(port2,==,9000); + tt_int_op(r,OP_EQ,AF_UNSPEC); + tt_int_op(tor_addr_family(&t1),OP_EQ,AF_UNSPEC); + tt_int_op(mask,OP_EQ,0); + tt_int_op(port1,OP_EQ,8000); + tt_int_op(port2,OP_EQ,9000); r=tor_addr_parse_mask_ports("*4:6667",TAPMP_EXTENDED_STAR, &t1,&mask,&port1,&port2); - tt_int_op(r,==,AF_INET); - tt_int_op(tor_addr_family(&t1),==,AF_INET); - tt_int_op(tor_addr_to_ipv4h(&t1),==,0); - tt_int_op(mask,==,0); - tt_int_op(port1,==,6667); - tt_int_op(port2,==,6667); + tt_int_op(r,OP_EQ,AF_INET); + tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET); + tt_int_op(tor_addr_to_ipv4h(&t1),OP_EQ,0); + tt_int_op(mask,OP_EQ,0); + tt_int_op(port1,OP_EQ,6667); + tt_int_op(port2,OP_EQ,6667); r=tor_addr_parse_mask_ports("*6",TAPMP_EXTENDED_STAR, &t1,&mask,&port1,&port2); - tt_int_op(r,==,AF_INET6); - tt_int_op(tor_addr_family(&t1),==,AF_INET6); + tt_int_op(r,OP_EQ,AF_INET6); + tt_int_op(tor_addr_family(&t1),OP_EQ,AF_INET6); tt_assert(tor_mem_is_zero((const char*)tor_addr_to_in6_addr32(&t1), 16)); - tt_int_op(mask,==,0); - tt_int_op(port1,==,1); - tt_int_op(port2,==,65535); + tt_int_op(mask,OP_EQ,0); + tt_int_op(port1,OP_EQ,1); + tt_int_op(port2,OP_EQ,65535);

/* make sure inet address lengths >= max */ tt_assert(INET_NTOA_BUF_LEN >= sizeof("255.255.255.255")); @@ -751,87 +751,87 @@ test_addr_parse(void *arg) r= tor_addr_port_parse(LOG_DEBUG, "192.0.2.1:1234", &addr, &port, -1); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); tor_addr_to_str(buf, &addr, sizeof(buf), 0); - tt_str_op(buf,==, "192.0.2.1"); - tt_int_op(port,==, 1234); + tt_str_op(buf,OP_EQ, "192.0.2.1"); + tt_int_op(port,OP_EQ, 1234);

r= tor_addr_port_parse(LOG_DEBUG, "[::1]:1234", &addr, &port, -1); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); tor_addr_to_str(buf, &addr, sizeof(buf), 0); - tt_str_op(buf,==, "::1"); - tt_int_op(port,==, 1234); + tt_str_op(buf,OP_EQ, "::1"); + tt_int_op(port,OP_EQ, 1234);

/* Domain name. */ r= tor_addr_port_parse(LOG_DEBUG, "torproject.org:1234", &addr, &port, -1); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1);

/* Only IP. */ r= tor_addr_port_parse(LOG_DEBUG, "192.0.2.2", &addr, &port, -1); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1);

r= tor_addr_port_parse(LOG_DEBUG, "192.0.2.2", &addr, &port, 200); - tt_int_op(r, ==, 0); - tt_int_op(port,==,200); + tt_int_op(r, OP_EQ, 0); + tt_int_op(port,OP_EQ,200);

r= tor_addr_port_parse(LOG_DEBUG, "[::1]", &addr, &port, -1); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1);

r= tor_addr_port_parse(LOG_DEBUG, "[::1]", &addr, &port, 400); - tt_int_op(r, ==, 0); - tt_int_op(port,==,400); + tt_int_op(r, OP_EQ, 0); + tt_int_op(port,OP_EQ,400);

/* Bad port. */ r= tor_addr_port_parse(LOG_DEBUG, "192.0.2.2:66666", &addr, &port, -1); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); r= tor_addr_port_parse(LOG_DEBUG, "192.0.2.2:66666", &addr, &port, 200); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1);

/* Only domain name */ r= tor_addr_port_parse(LOG_DEBUG, "torproject.org", &addr, &port, -1); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1); r= tor_addr_port_parse(LOG_DEBUG, "torproject.org", &addr, &port, 200); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1);

/* Bad IP address */ r= tor_addr_port_parse(LOG_DEBUG, "192.0.2:1234", &addr, &port, -1); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1);

/* Make sure that the default port has lower priority than the real one */ r= tor_addr_port_parse(LOG_DEBUG, "192.0.2.2:1337", &addr, &port, 200); - tt_int_op(r, ==, 0); - tt_int_op(port,==,1337); + tt_int_op(r, OP_EQ, 0); + tt_int_op(port,OP_EQ,1337);

r= tor_addr_port_parse(LOG_DEBUG, "[::1]:1369", &addr, &port, 200); - tt_int_op(r, ==, 0); - tt_int_op(port,==,1369); + tt_int_op(r, OP_EQ, 0); + tt_int_op(port,OP_EQ,1369);

done: ; @@ -886,7 +886,7 @@ test_virtaddrmap(void *data) get_random_virtual_addr(&cfg[ipv6], &a); //printf("%s\n", fmt_addr(&a)); /* Make sure that the first b bits match the configured network */ - tt_int_op(0, ==, tor_addr_compare_masked(&a, &cfg[ipv6].addr, + tt_int_op(0, OP_EQ, tor_addr_compare_masked(&a, &cfg[ipv6].addr, bits, CMP_EXACT));

/* And track which bits have been different between pairs of @@ -930,7 +930,7 @@ test_addr_dup_ip(void *arg) (void)arg; #define CHECK(ip, s) do { \ v = tor_dup_ip(ip); \ - tt_str_op(v,==,(s)); \ + tt_str_op(v,OP_EQ,(s)); \ tor_free(v); \ } while (0)

@@ -956,7 +956,7 @@ test_addr_sockaddr_to_str(void *arg) #endif #define CHECK(sa, s) do { \ v = tor_sockaddr_to_str((const struct sockaddr*) &(sa)); \ - tt_str_op(v,==,(s)); \ + tt_str_op(v,OP_EQ,(s)); \ tor_free(v); \ } while (0) (void)arg; @@ -1013,12 +1013,12 @@ test_addr_is_loopback(void *data) (void)data;

for (i=0; loopback_items[i].name; ++i) { - tt_int_op(tor_addr_parse(&addr, loopback_items[i].name), >=, 0); - tt_int_op(tor_addr_is_loopback(&addr), ==, loopback_items[i].is_loopback); + tt_int_op(tor_addr_parse(&addr, loopback_items[i].name), OP_GE, 0); + tt_int_op(tor_addr_is_loopback(&addr), OP_EQ, loopback_items[i].is_loopback); }

tor_addr_make_unspec(&addr); - tt_int_op(tor_addr_is_loopback(&addr), ==, 0); + tt_int_op(tor_addr_is_loopback(&addr), OP_EQ, 0);

done: ; @@ -1033,18 +1033,18 @@ test_addr_make_null(void *data) (void) data; /* Ensure that before tor_addr_make_null, addr != 0's */ memset(addr, 1, sizeof(*addr)); - tt_int_op(memcmp(addr, zeros, sizeof(*addr)), !=, 0); + tt_int_op(memcmp(addr, zeros, sizeof(*addr)), OP_NE, 0); /* Test with AF == AF_INET */ zeros->family = AF_INET; tor_addr_make_null(addr, AF_INET); - tt_int_op(memcmp(addr, zeros, sizeof(*addr)), ==, 0); - tt_str_op(tor_addr_to_str(buf, addr, sizeof(buf), 0), ==, "0.0.0.0"); + tt_int_op(memcmp(addr, zeros, sizeof(*addr)), OP_EQ, 0); + tt_str_op(tor_addr_to_str(buf, addr, sizeof(buf), 0), OP_EQ, "0.0.0.0"); /* Test with AF == AF_INET6 */ memset(addr, 1, sizeof(*addr)); zeros->family = AF_INET6; tor_addr_make_null(addr, AF_INET6); - tt_int_op(memcmp(addr, zeros, sizeof(*addr)), ==, 0); - tt_str_op(tor_addr_to_str(buf, addr, sizeof(buf), 0), ==, "::"); + tt_int_op(memcmp(addr, zeros, sizeof(*addr)), OP_EQ, 0); + tt_str_op(tor_addr_to_str(buf, addr, sizeof(buf), 0), OP_EQ, "::"); done: tor_free(addr); tor_free(zeros); diff --git a/src/test/test_buffers.c b/src/test/test_buffers.c index cea7190..7e42124 100644 --- a/src/test/test_buffers.c +++ b/src/test/test_buffers.c @@ -30,7 +30,7 @@ test_buffers_basic(void *arg) TT_DIE(("Assertion failed."));

//test_eq(buf_capacity(buf), 4096); - tt_int_op(buf_datalen(buf),==, 0); + tt_int_op(buf_datalen(buf),OP_EQ, 0);

/**** * General pointer frobbing @@ -40,16 +40,16 @@ test_buffers_basic(void *arg) } write_to_buf(str, 256, buf); write_to_buf(str, 256, buf); - tt_int_op(buf_datalen(buf),==, 512); + tt_int_op(buf_datalen(buf),OP_EQ, 512); fetch_from_buf(str2, 200, buf); - tt_mem_op(str,==, str2, 200); - tt_int_op(buf_datalen(buf),==, 312); + tt_mem_op(str,OP_EQ, str2, 200); + tt_int_op(buf_datalen(buf),OP_EQ, 312); memset(str2, 0, sizeof(str2));

fetch_from_buf(str2, 256, buf); - tt_mem_op(str+200,==, str2, 56); - tt_mem_op(str,==, str2+56, 200); - tt_int_op(buf_datalen(buf),==, 56); + tt_mem_op(str+200,OP_EQ, str2, 56); + tt_mem_op(str,OP_EQ, str2+56, 200); + tt_int_op(buf_datalen(buf),OP_EQ, 56); memset(str2, 0, sizeof(str2)); /* Okay, now we should be 512 bytes into the 4096-byte buffer. If we add * another 3584 bytes, we hit the end. */ @@ -57,16 +57,16 @@ test_buffers_basic(void *arg) write_to_buf(str, 256, buf); } assert_buf_ok(buf); - tt_int_op(buf_datalen(buf),==, 3896); + tt_int_op(buf_datalen(buf),OP_EQ, 3896); fetch_from_buf(str2, 56, buf); - tt_int_op(buf_datalen(buf),==, 3840); - tt_mem_op(str+200,==, str2, 56); + tt_int_op(buf_datalen(buf),OP_EQ, 3840); + tt_mem_op(str+200,OP_EQ, str2, 56); for (j=0;j<15;++j) { memset(str2, 0, sizeof(str2)); fetch_from_buf(str2, 256, buf); - tt_mem_op(str,==, str2, 256); + tt_mem_op(str,OP_EQ, str2, 256); } - tt_int_op(buf_datalen(buf),==, 0); + tt_int_op(buf_datalen(buf),OP_EQ, 0); buf_free(buf); buf = NULL;

@@ -76,7 +76,7 @@ test_buffers_basic(void *arg) write_to_buf(str+1, 255, buf); //test_eq(buf_capacity(buf), 256); fetch_from_buf(str2, 254, buf); - tt_mem_op(str+1,==, str2, 254); + tt_mem_op(str+1,OP_EQ, str2, 254); //test_eq(buf_capacity(buf), 256); assert_buf_ok(buf); write_to_buf(str, 32, buf); @@ -85,15 +85,15 @@ test_buffers_basic(void *arg) write_to_buf(str, 256, buf); assert_buf_ok(buf); //test_eq(buf_capacity(buf), 512); - tt_int_op(buf_datalen(buf),==, 33+256); + tt_int_op(buf_datalen(buf),OP_EQ, 33+256); fetch_from_buf(str2, 33, buf); - tt_int_op(*str2,==, str[255]); + tt_int_op(*str2,OP_EQ, str[255]);

- tt_mem_op(str2+1,==, str, 32); + tt_mem_op(str2+1,OP_EQ, str, 32); //test_eq(buf_capacity(buf), 512); - tt_int_op(buf_datalen(buf),==, 256); + tt_int_op(buf_datalen(buf),OP_EQ, 256); fetch_from_buf(str2, 256, buf); - tt_mem_op(str,==, str2, 256); + tt_mem_op(str,OP_EQ, str2, 256);

/* now try shrinking: case 1. */ buf_free(buf); @@ -102,10 +102,10 @@ test_buffers_basic(void *arg) write_to_buf(str,255, buf); } //test_eq(buf_capacity(buf), 33668); - tt_int_op(buf_datalen(buf),==, 17085); + tt_int_op(buf_datalen(buf),OP_EQ, 17085); for (j=0; j < 40; ++j) { fetch_from_buf(str2, 255,buf); - tt_mem_op(str2,==, str, 255); + tt_mem_op(str2,OP_EQ, str, 255); }

/* now try shrinking: case 2. */ @@ -116,7 +116,7 @@ test_buffers_basic(void *arg) } for (j=0; j < 20; ++j) { fetch_from_buf(str2, 255,buf); - tt_mem_op(str2,==, str, 255); + tt_mem_op(str2,OP_EQ, str, 255); } for (j=0;j<80;++j) { write_to_buf(str,255, buf); @@ -124,7 +124,7 @@ test_buffers_basic(void *arg) //test_eq(buf_capacity(buf),33668); for (j=0; j < 120; ++j) { fetch_from_buf(str2, 255,buf); - tt_mem_op(str2,==, str, 255); + tt_mem_op(str2,OP_EQ, str, 255); }

/* Move from buf to buf. */ @@ -133,27 +133,27 @@ test_buffers_basic(void *arg) buf2 = buf_new_with_capacity(4096); for (j=0;j<100;++j) write_to_buf(str, 255, buf); - tt_int_op(buf_datalen(buf),==, 25500); + tt_int_op(buf_datalen(buf),OP_EQ, 25500); for (j=0;j<100;++j) { r = 10; move_buf_to_buf(buf2, buf, &r); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0); } - tt_int_op(buf_datalen(buf),==, 24500); - tt_int_op(buf_datalen(buf2),==, 1000); + tt_int_op(buf_datalen(buf),OP_EQ, 24500); + tt_int_op(buf_datalen(buf2),OP_EQ, 1000); for (j=0;j<3;++j) { fetch_from_buf(str2, 255, buf2); - tt_mem_op(str2,==, str, 255); + tt_mem_op(str2,OP_EQ, str, 255); } r = 8192; /*big move*/ move_buf_to_buf(buf2, buf, &r); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0); r = 30000; /* incomplete move */ move_buf_to_buf(buf2, buf, &r); - tt_int_op(r,==, 13692); + tt_int_op(r,OP_EQ, 13692); for (j=0;j<97;++j) { fetch_from_buf(str2, 255, buf2); - tt_mem_op(str2,==, str, 255); + tt_mem_op(str2,OP_EQ, str, 255); } buf_free(buf); buf_free(buf2); @@ -163,16 +163,16 @@ test_buffers_basic(void *arg) cp = "Testing. This is a moderately long Testing string."; for (j = 0; cp[j]; j++) write_to_buf(cp+j, 1, buf); - tt_int_op(0,==, buf_find_string_offset(buf, "Testing", 7)); - tt_int_op(1,==, buf_find_string_offset(buf, "esting", 6)); - tt_int_op(1,==, buf_find_string_offset(buf, "est", 3)); - tt_int_op(39,==, buf_find_string_offset(buf, "ing str", 7)); - tt_int_op(35,==, buf_find_string_offset(buf, "Testing str", 11)); - tt_int_op(32,==, buf_find_string_offset(buf, "ng ", 3)); - tt_int_op(43,==, buf_find_string_offset(buf, "string.", 7)); - tt_int_op(-1,==, buf_find_string_offset(buf, "shrdlu", 6)); - tt_int_op(-1,==, buf_find_string_offset(buf, "Testing thing", 13)); - tt_int_op(-1,==, buf_find_string_offset(buf, "ngx", 3)); + tt_int_op(0,OP_EQ, buf_find_string_offset(buf, "Testing", 7)); + tt_int_op(1,OP_EQ, buf_find_string_offset(buf, "esting", 6)); + tt_int_op(1,OP_EQ, buf_find_string_offset(buf, "est", 3)); + tt_int_op(39,OP_EQ, buf_find_string_offset(buf, "ing str", 7)); + tt_int_op(35,OP_EQ, buf_find_string_offset(buf, "Testing str", 11)); + tt_int_op(32,OP_EQ, buf_find_string_offset(buf, "ng ", 3)); + tt_int_op(43,OP_EQ, buf_find_string_offset(buf, "string.", 7)); + tt_int_op(-1,OP_EQ, buf_find_string_offset(buf, "shrdlu", 6)); + tt_int_op(-1,OP_EQ, buf_find_string_offset(buf, "Testing thing", 13)); + tt_int_op(-1,OP_EQ, buf_find_string_offset(buf, "ngx", 3)); buf_free(buf); buf = NULL;

@@ -183,7 +183,7 @@ test_buffers_basic(void *arg) write_to_buf(cp, 65536, buf); tor_free(cp);

- tt_int_op(buf_datalen(buf), ==, 65536); + tt_int_op(buf_datalen(buf), OP_EQ, 65536); buf_free(buf); buf = NULL; } @@ -213,19 +213,19 @@ test_buffer_pullup(void *arg) buf = buf_new_with_capacity(3000); /* rounds up to next power of 2. */

tt_assert(buf); - tt_int_op(buf_get_default_chunk_size(buf), ==, 4096); + tt_int_op(buf_get_default_chunk_size(buf), OP_EQ, 4096);

- tt_int_op(buf_get_total_allocation(), ==, 0); + tt_int_op(buf_get_total_allocation(), OP_EQ, 0);

/* There are a bunch of cases for pullup. One is the trivial case. Let's mess around with an empty buffer. */ buf_pullup(buf, 16, 1); buf_get_first_chunk_data(buf, &cp, &sz); - tt_ptr_op(cp, ==, NULL); - tt_uint_op(sz, ==, 0); + tt_ptr_op(cp, OP_EQ, NULL); + tt_uint_op(sz, OP_EQ, 0);

/* Let's make sure nothing got allocated */ - tt_int_op(buf_get_total_allocation(), ==, 0); + tt_int_op(buf_get_total_allocation(), OP_EQ, 0);

/* Case 1: everything puts into the first chunk with some moving. */

@@ -234,22 +234,22 @@ test_buffer_pullup(void *arg) write_to_buf(stuff, 3000, buf); write_to_buf(stuff+3000, 3000, buf); buf_get_first_chunk_data(buf, &cp, &sz); - tt_ptr_op(cp, !=, NULL); - tt_int_op(sz, <=, 4096); + tt_ptr_op(cp, OP_NE, NULL); + tt_int_op(sz, OP_LE, 4096);

/* Make room for 3000 bytes in the first chunk, so that the pullup-move code * can get tested. */ - tt_int_op(fetch_from_buf(tmp, 3000, buf), ==, 3000); - tt_mem_op(tmp,==, stuff, 3000); + tt_int_op(fetch_from_buf(tmp, 3000, buf), OP_EQ, 3000); + tt_mem_op(tmp,OP_EQ, stuff, 3000); buf_pullup(buf, 2048, 0); assert_buf_ok(buf); buf_get_first_chunk_data(buf, &cp, &sz); - tt_ptr_op(cp, !=, NULL); - tt_int_op(sz, >=, 2048); - tt_mem_op(cp,==, stuff+3000, 2048); - tt_int_op(3000, ==, buf_datalen(buf)); - tt_int_op(fetch_from_buf(tmp, 3000, buf), ==, 0); - tt_mem_op(tmp,==, stuff+3000, 2048); + tt_ptr_op(cp, OP_NE, NULL); + tt_int_op(sz, OP_GE, 2048); + tt_mem_op(cp,OP_EQ, stuff+3000, 2048); + tt_int_op(3000, OP_EQ, buf_datalen(buf)); + tt_int_op(fetch_from_buf(tmp, 3000, buf), OP_EQ, 0); + tt_mem_op(tmp,OP_EQ, stuff+3000, 2048);

buf_free(buf);

@@ -259,26 +259,26 @@ test_buffer_pullup(void *arg) write_to_buf(stuff+4000, 4000, buf); write_to_buf(stuff+8000, 4000, buf); write_to_buf(stuff+12000, 4000, buf); - tt_int_op(buf_datalen(buf), ==, 16000); + tt_int_op(buf_datalen(buf), OP_EQ, 16000); buf_get_first_chunk_data(buf, &cp, &sz); - tt_ptr_op(cp, !=, NULL); - tt_int_op(sz, <=, 4096); + tt_ptr_op(cp, OP_NE, NULL); + tt_int_op(sz, OP_LE, 4096);

buf_pullup(buf, 12500, 0); assert_buf_ok(buf); buf_get_first_chunk_data(buf, &cp, &sz); - tt_ptr_op(cp, !=, NULL); - tt_int_op(sz, >=, 12500); - tt_mem_op(cp,==, stuff, 12500); - tt_int_op(buf_datalen(buf), ==, 16000); + tt_ptr_op(cp, OP_NE, NULL); + tt_int_op(sz, OP_GE, 12500); + tt_mem_op(cp,OP_EQ, stuff, 12500); + tt_int_op(buf_datalen(buf), OP_EQ, 16000);

fetch_from_buf(tmp, 12400, buf); - tt_mem_op(tmp,==, stuff, 12400); - tt_int_op(buf_datalen(buf), ==, 3600); + tt_mem_op(tmp,OP_EQ, stuff, 12400); + tt_int_op(buf_datalen(buf), OP_EQ, 3600); fetch_from_buf(tmp, 3500, buf); - tt_mem_op(tmp,==, stuff+12400, 3500); + tt_mem_op(tmp,OP_EQ, stuff+12400, 3500); fetch_from_buf(tmp, 100, buf); - tt_mem_op(tmp,==, stuff+15900, 10); + tt_mem_op(tmp,OP_EQ, stuff+15900, 10);

buf_free(buf);

@@ -290,16 +290,16 @@ test_buffer_pullup(void *arg) buf_pullup(buf, 16000, 0); /* Way too much. */ assert_buf_ok(buf); buf_get_first_chunk_data(buf, &cp, &sz); - tt_ptr_op(cp, !=, NULL); - tt_int_op(sz, ==, 7900); - tt_mem_op(cp,==, stuff+100, 7900); + tt_ptr_op(cp, OP_NE, NULL); + tt_int_op(sz, OP_EQ, 7900); + tt_mem_op(cp,OP_EQ, stuff+100, 7900);

buf_free(buf); buf = NULL;

buf_shrink_freelists(1);

- tt_int_op(buf_get_total_allocation(), ==, 0); + tt_int_op(buf_get_total_allocation(), OP_EQ, 0); done: buf_free(buf); buf_shrink_freelists(1); @@ -321,31 +321,31 @@ test_buffer_copy(void *arg) tt_assert(buf);

/* Copy an empty buffer. */ - tt_int_op(0, ==, generic_buffer_set_to_copy(&buf2, buf)); + tt_int_op(0, OP_EQ, generic_buffer_set_to_copy(&buf2, buf)); tt_assert(buf2); - tt_int_op(0, ==, generic_buffer_len(buf2)); + tt_int_op(0, OP_EQ, generic_buffer_len(buf2));

/* Now try with a short buffer. */ s = "And now comes an act of enormous enormance!"; len = strlen(s); generic_buffer_add(buf, s, len); - tt_int_op(len, ==, generic_buffer_len(buf)); + tt_int_op(len, OP_EQ, generic_buffer_len(buf)); /* Add junk to buf2 so we can test replacing.*/ generic_buffer_add(buf2, "BLARG", 5); - tt_int_op(0, ==, generic_buffer_set_to_copy(&buf2, buf)); - tt_int_op(len, ==, generic_buffer_len(buf2)); + tt_int_op(0, OP_EQ, generic_buffer_set_to_copy(&buf2, buf)); + tt_int_op(len, OP_EQ, generic_buffer_len(buf2)); generic_buffer_get(buf2, b, len); - tt_mem_op(b, ==, s, len); + tt_mem_op(b, OP_EQ, s, len); /* Now free buf2 and retry so we can test allocating */ generic_buffer_free(buf2); buf2 = NULL; - tt_int_op(0, ==, generic_buffer_set_to_copy(&buf2, buf)); - tt_int_op(len, ==, generic_buffer_len(buf2)); + tt_int_op(0, OP_EQ, generic_buffer_set_to_copy(&buf2, buf)); + tt_int_op(len, OP_EQ, generic_buffer_len(buf2)); generic_buffer_get(buf2, b, len); - tt_mem_op(b, ==, s, len); + tt_mem_op(b, OP_EQ, s, len); /* Clear buf for next test */ generic_buffer_get(buf, b, len); - tt_int_op(generic_buffer_len(buf),==,0); + tt_int_op(generic_buffer_len(buf),OP_EQ,0);

/* Okay, now let's try a bigger buffer. */ s = "Quis autem vel eum iure reprehenderit qui in ea voluptate velit " @@ -357,12 +357,12 @@ test_buffer_copy(void *arg) generic_buffer_add(buf, b, 1); generic_buffer_add(buf, s, len); } - tt_int_op(0, ==, generic_buffer_set_to_copy(&buf2, buf)); - tt_int_op(generic_buffer_len(buf2), ==, generic_buffer_len(buf)); + tt_int_op(0, OP_EQ, generic_buffer_set_to_copy(&buf2, buf)); + tt_int_op(generic_buffer_len(buf2), OP_EQ, generic_buffer_len(buf)); for (i = 0; i < 256; ++i) { generic_buffer_get(buf2, b, len+1); - tt_int_op((unsigned char)b[0],==,i); - tt_mem_op(b+1, ==, s, len); + tt_int_op((unsigned char)b[0],OP_EQ,i); + tt_mem_op(b+1, OP_EQ, s, len); }

done: @@ -382,62 +382,62 @@ test_buffer_ext_or_cmd(void *arg) (void) arg;

/* Empty -- should give "not there. */ - tt_int_op(0, ==, generic_buffer_fetch_ext_or_cmd(buf, &cmd)); - tt_ptr_op(NULL, ==, cmd); + tt_int_op(0, OP_EQ, generic_buffer_fetch_ext_or_cmd(buf, &cmd)); + tt_ptr_op(NULL, OP_EQ, cmd);

/* Three bytes: shouldn't work. */ generic_buffer_add(buf, "\x00\x20\x00", 3); - tt_int_op(0, ==, generic_buffer_fetch_ext_or_cmd(buf, &cmd)); - tt_ptr_op(NULL, ==, cmd); - tt_int_op(3, ==, generic_buffer_len(buf)); + tt_int_op(0, OP_EQ, generic_buffer_fetch_ext_or_cmd(buf, &cmd)); + tt_ptr_op(NULL, OP_EQ, cmd); + tt_int_op(3, OP_EQ, generic_buffer_len(buf));

/* 0020 0000: That's a nil command. It should work. */ generic_buffer_add(buf, "\x00", 1); - tt_int_op(1, ==, generic_buffer_fetch_ext_or_cmd(buf, &cmd)); - tt_ptr_op(NULL, !=, cmd); - tt_int_op(0x20, ==, cmd->cmd); - tt_int_op(0, ==, cmd->len); - tt_int_op(0, ==, generic_buffer_len(buf)); + tt_int_op(1, OP_EQ, generic_buffer_fetch_ext_or_cmd(buf, &cmd)); + tt_ptr_op(NULL, OP_NE, cmd); + tt_int_op(0x20, OP_EQ, cmd->cmd); + tt_int_op(0, OP_EQ, cmd->len); + tt_int_op(0, OP_EQ, generic_buffer_len(buf)); ext_or_cmd_free(cmd); cmd = NULL;

/* Now try a length-6 command with one byte missing. */ generic_buffer_add(buf, "\x10\x21\x00\x06""abcde", 9); - tt_int_op(0, ==, generic_buffer_fetch_ext_or_cmd(buf, &cmd)); - tt_ptr_op(NULL, ==, cmd); + tt_int_op(0, OP_EQ, generic_buffer_fetch_ext_or_cmd(buf, &cmd)); + tt_ptr_op(NULL, OP_EQ, cmd); generic_buffer_add(buf, "f", 1); - tt_int_op(1, ==, generic_buffer_fetch_ext_or_cmd(buf, &cmd)); - tt_ptr_op(NULL, !=, cmd); - tt_int_op(0x1021, ==, cmd->cmd); - tt_int_op(6, ==, cmd->len); - tt_mem_op("abcdef", ==, cmd->body, 6); - tt_int_op(0, ==, generic_buffer_len(buf)); + tt_int_op(1, OP_EQ, generic_buffer_fetch_ext_or_cmd(buf, &cmd)); + tt_ptr_op(NULL, OP_NE, cmd); + tt_int_op(0x1021, OP_EQ, cmd->cmd); + tt_int_op(6, OP_EQ, cmd->len); + tt_mem_op("abcdef", OP_EQ, cmd->body, 6); + tt_int_op(0, OP_EQ, generic_buffer_len(buf)); ext_or_cmd_free(cmd); cmd = NULL;

/* Now try a length-10 command with 4 extra bytes. */ generic_buffer_add(buf, "\xff\xff\x00\x0a" "loremipsum\x10\x00\xff\xff", 18); - tt_int_op(1, ==, generic_buffer_fetch_ext_or_cmd(buf, &cmd)); - tt_ptr_op(NULL, !=, cmd); - tt_int_op(0xffff, ==, cmd->cmd); - tt_int_op(10, ==, cmd->len); - tt_mem_op("loremipsum", ==, cmd->body, 10); - tt_int_op(4, ==, generic_buffer_len(buf)); + tt_int_op(1, OP_EQ, generic_buffer_fetch_ext_or_cmd(buf, &cmd)); + tt_ptr_op(NULL, OP_NE, cmd); + tt_int_op(0xffff, OP_EQ, cmd->cmd); + tt_int_op(10, OP_EQ, cmd->len); + tt_mem_op("loremipsum", OP_EQ, cmd->body, 10); + tt_int_op(4, OP_EQ, generic_buffer_len(buf)); ext_or_cmd_free(cmd); cmd = NULL;

/* Finally, let's try a maximum-length command. We already have the header * waiting. */ - tt_int_op(0, ==, generic_buffer_fetch_ext_or_cmd(buf, &cmd)); + tt_int_op(0, OP_EQ, generic_buffer_fetch_ext_or_cmd(buf, &cmd)); tmp = tor_malloc_zero(65535); generic_buffer_add(buf, tmp, 65535); - tt_int_op(1, ==, generic_buffer_fetch_ext_or_cmd(buf, &cmd)); - tt_ptr_op(NULL, !=, cmd); - tt_int_op(0x1000, ==, cmd->cmd); - tt_int_op(0xffff, ==, cmd->len); - tt_mem_op(tmp, ==, cmd->body, 65535); - tt_int_op(0, ==, generic_buffer_len(buf)); + tt_int_op(1, OP_EQ, generic_buffer_fetch_ext_or_cmd(buf, &cmd)); + tt_ptr_op(NULL, OP_NE, cmd); + tt_int_op(0x1000, OP_EQ, cmd->cmd); + tt_int_op(0xffff, OP_EQ, cmd->len); + tt_mem_op(tmp, OP_EQ, cmd->body, 65535); + tt_int_op(0, OP_EQ, generic_buffer_len(buf)); ext_or_cmd_free(cmd); cmd = NULL;

@@ -458,65 +458,65 @@ test_buffer_allocation_tracking(void *arg) (void)arg;

crypto_rand(junk, 16384); - tt_int_op(buf_get_total_allocation(), ==, 0); + tt_int_op(buf_get_total_allocation(), OP_EQ, 0);

buf1 = buf_new(); tt_assert(buf1); buf2 = buf_new(); tt_assert(buf2);

- tt_int_op(buf_allocation(buf1), ==, 0); - tt_int_op(buf_get_total_allocation(), ==, 0); + tt_int_op(buf_allocation(buf1), OP_EQ, 0); + tt_int_op(buf_get_total_allocation(), OP_EQ, 0);

write_to_buf(junk, 4000, buf1); write_to_buf(junk, 4000, buf1); write_to_buf(junk, 4000, buf1); write_to_buf(junk, 4000, buf1); - tt_int_op(buf_allocation(buf1), ==, 16384); + tt_int_op(buf_allocation(buf1), OP_EQ, 16384); fetch_from_buf(junk, 100, buf1); - tt_int_op(buf_allocation(buf1), ==, 16384); /* still 4 4k chunks */ + tt_int_op(buf_allocation(buf1), OP_EQ, 16384); /* still 4 4k chunks */

- tt_int_op(buf_get_total_allocation(), ==, 16384); + tt_int_op(buf_get_total_allocation(), OP_EQ, 16384);

fetch_from_buf(junk, 4096, buf1); /* drop a 1k chunk... */ - tt_int_op(buf_allocation(buf1), ==, 3*4096); /* now 3 4k chunks */ + tt_int_op(buf_allocation(buf1), OP_EQ, 3*4096); /* now 3 4k chunks */

#ifdef ENABLE_BUF_FREELISTS - tt_int_op(buf_get_total_allocation(), ==, 16384); /* that chunk went onto + tt_int_op(buf_get_total_allocation(), OP_EQ, 16384); /* that chunk went onto the freelist. */ #else - tt_int_op(buf_get_total_allocation(), ==, 12288); /* that chunk was really + tt_int_op(buf_get_total_allocation(), OP_EQ, 12288); /* that chunk was really freed. */ #endif

write_to_buf(junk, 4000, buf2); - tt_int_op(buf_allocation(buf2), ==, 4096); /* another 4k chunk. */ + tt_int_op(buf_allocation(buf2), OP_EQ, 4096); /* another 4k chunk. */ /* * If we're using freelists, size stays at 16384 because we just pulled a * chunk from the freelist. If we aren't, we bounce back up to 16384 by * allocating a new chunk. */ - tt_int_op(buf_get_total_allocation(), ==, 16384); + tt_int_op(buf_get_total_allocation(), OP_EQ, 16384); write_to_buf(junk, 4000, buf2); - tt_int_op(buf_allocation(buf2), ==, 8192); /* another 4k chunk. */ - tt_int_op(buf_get_total_allocation(), ==, 5*4096); /* that chunk was new. */ + tt_int_op(buf_allocation(buf2), OP_EQ, 8192); /* another 4k chunk. */ + tt_int_op(buf_get_total_allocation(), OP_EQ, 5*4096); /* that chunk was new. */

/* Make a really huge buffer */ for (i = 0; i < 1000; ++i) { write_to_buf(junk, 4000, buf2); } - tt_int_op(buf_allocation(buf2), >=, 4008000); - tt_int_op(buf_get_total_allocation(), >=, 4008000); + tt_int_op(buf_allocation(buf2), OP_GE, 4008000); + tt_int_op(buf_get_total_allocation(), OP_GE, 4008000); buf_free(buf2); buf2 = NULL;

- tt_int_op(buf_get_total_allocation(), <, 4008000); + tt_int_op(buf_get_total_allocation(), OP_LT, 4008000); buf_shrink_freelists(1); - tt_int_op(buf_get_total_allocation(), ==, buf_allocation(buf1)); + tt_int_op(buf_get_total_allocation(), OP_EQ, buf_allocation(buf1)); buf_free(buf1); buf1 = NULL; buf_shrink_freelists(1); - tt_int_op(buf_get_total_allocation(), ==, 0); + tt_int_op(buf_get_total_allocation(), OP_EQ, 0);

done: buf_free(buf1); @@ -545,37 +545,37 @@ test_buffer_time_tracking(void *arg) tt_assert(buf);

/* Empty buffer means the timestamp is 0. */ - tt_int_op(0, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC)); - tt_int_op(0, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC+1000)); + tt_int_op(0, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC)); + tt_int_op(0, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+1000));

tor_gettimeofday_cache_set(&tv0); write_to_buf("ABCDEFG", 7, buf); - tt_int_op(1000, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC+1000)); + tt_int_op(1000, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+1000));

buf2 = buf_copy(buf); tt_assert(buf2); - tt_int_op(1234, ==, buf_get_oldest_chunk_timestamp(buf2, START_MSEC+1234)); + tt_int_op(1234, OP_EQ, buf_get_oldest_chunk_timestamp(buf2, START_MSEC+1234));

/* Now add more bytes; enough to overflow the first chunk. */ tv0.tv_usec += 123 * 1000; tor_gettimeofday_cache_set(&tv0); for (i = 0; i < 600; ++i) write_to_buf("ABCDEFG", 7, buf); - tt_int_op(4207, ==, buf_datalen(buf)); + tt_int_op(4207, OP_EQ, buf_datalen(buf));

/* The oldest bytes are still in the front. */ - tt_int_op(2000, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2000)); + tt_int_op(2000, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2000));

/* Once those bytes are dropped, the chunk is still on the first * timestamp. */ fetch_from_buf(tmp, 100, buf); - tt_int_op(2000, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2000)); + tt_int_op(2000, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2000));

/* But once we discard the whole first chunk, we get the data in the second * chunk. */ fetch_from_buf(tmp, 4000, buf); - tt_int_op(107, ==, buf_datalen(buf)); - tt_int_op(2000, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2123)); + tt_int_op(107, OP_EQ, buf_datalen(buf)); + tt_int_op(2000, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2123));

/* This time we'll be grabbing a chunk from the freelist, and making sure its time gets updated */ @@ -584,13 +584,13 @@ test_buffer_time_tracking(void *arg) tor_gettimeofday_cache_set(&tv0); for (i = 0; i < 600; ++i) write_to_buf("ABCDEFG", 7, buf); - tt_int_op(4307, ==, buf_datalen(buf)); + tt_int_op(4307, OP_EQ, buf_datalen(buf));

- tt_int_op(2000, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2123)); + tt_int_op(2000, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2123)); fetch_from_buf(tmp, 4000, buf); fetch_from_buf(tmp, 306, buf); - tt_int_op(0, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC+5617)); - tt_int_op(383, ==, buf_get_oldest_chunk_timestamp(buf, START_MSEC+6000)); + tt_int_op(0, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+5617)); + tt_int_op(383, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+6000));

done: buf_free(buf); @@ -613,31 +613,31 @@ test_buffers_zlib_impl(int finalize_with_nil)

msg = tor_malloc(512); crypto_rand(msg, 512); - tt_int_op(write_to_buf_zlib(buf, zlib_state, msg, 128, 0), ==, 0); - tt_int_op(write_to_buf_zlib(buf, zlib_state, msg+128, 128, 0), ==, 0); - tt_int_op(write_to_buf_zlib(buf, zlib_state, msg+256, 256, 0), ==, 0); + tt_int_op(write_to_buf_zlib(buf, zlib_state, msg, 128, 0), OP_EQ, 0); + tt_int_op(write_to_buf_zlib(buf, zlib_state, msg+128, 128, 0), OP_EQ, 0); + tt_int_op(write_to_buf_zlib(buf, zlib_state, msg+256, 256, 0), OP_EQ, 0); done = !finalize_with_nil; - tt_int_op(write_to_buf_zlib(buf, zlib_state, "all done", 9, done), ==, 0); + tt_int_op(write_to_buf_zlib(buf, zlib_state, "all done", 9, done), OP_EQ, 0); if (finalize_with_nil) { - tt_int_op(write_to_buf_zlib(buf, zlib_state, "", 0, 1), ==, 0); + tt_int_op(write_to_buf_zlib(buf, zlib_state, "", 0, 1), OP_EQ, 0); }

in_len = buf_datalen(buf); contents = tor_malloc(in_len);

- tt_int_op(fetch_from_buf(contents, in_len, buf), ==, 0); + tt_int_op(fetch_from_buf(contents, in_len, buf), OP_EQ, 0);

- tt_int_op(0, ==, tor_gzip_uncompress(&expanded, &out_len, + tt_int_op(0, OP_EQ, tor_gzip_uncompress(&expanded, &out_len, contents, in_len, ZLIB_METHOD, 1, LOG_WARN));

- tt_int_op(out_len, >=, 128); - tt_mem_op(msg, ==, expanded, 128); - tt_int_op(out_len, >=, 512); - tt_mem_op(msg, ==, expanded, 512); - tt_int_op(out_len, ==, 512+9); - tt_mem_op("all done", ==, expanded+512, 9); + tt_int_op(out_len, OP_GE, 128); + tt_mem_op(msg, OP_EQ, expanded, 128); + tt_int_op(out_len, OP_GE, 512); + tt_mem_op(msg, OP_EQ, expanded, 512); + tt_int_op(out_len, OP_EQ, 512+9); + tt_mem_op("all done", OP_EQ, expanded+512, 9);

done: buf_free(buf); @@ -680,28 +680,28 @@ test_buffers_zlib_fin_at_chunk_end(void *arg) tt_assert(buf->head);

/* Fill up the chunk so the zlib stuff won't fit in one chunk. */ - tt_uint_op(buf->head->memlen, <, sz); + tt_uint_op(buf->head->memlen, OP_LT, sz); headerjunk = buf->head->memlen - 7; write_to_buf(msg, headerjunk-1, buf); - tt_uint_op(buf->head->datalen, ==, headerjunk); - tt_uint_op(buf_datalen(buf), ==, headerjunk); + tt_uint_op(buf->head->datalen, OP_EQ, headerjunk); + tt_uint_op(buf_datalen(buf), OP_EQ, headerjunk); /* Write an empty string, with finalization on. */ zlib_state = tor_zlib_new(1, ZLIB_METHOD); - tt_int_op(write_to_buf_zlib(buf, zlib_state, "", 0, 1), ==, 0); + tt_int_op(write_to_buf_zlib(buf, zlib_state, "", 0, 1), OP_EQ, 0);

in_len = buf_datalen(buf); contents = tor_malloc(in_len);

- tt_int_op(fetch_from_buf(contents, in_len, buf), ==, 0); + tt_int_op(fetch_from_buf(contents, in_len, buf), OP_EQ, 0);

- tt_uint_op(in_len, >, headerjunk); + tt_uint_op(in_len, OP_GT, headerjunk);

- tt_int_op(0, ==, tor_gzip_uncompress(&expanded, &out_len, + tt_int_op(0, OP_EQ, tor_gzip_uncompress(&expanded, &out_len, contents + headerjunk, in_len - headerjunk, ZLIB_METHOD, 1, LOG_WARN));

- tt_int_op(out_len, ==, 0); + tt_int_op(out_len, OP_EQ, 0); tt_assert(expanded);

done: diff --git a/src/test/test_cell_formats.c b/src/test/test_cell_formats.c index 19ecedc..edc011f 100644 --- a/src/test/test_cell_formats.c +++ b/src/test/test_cell_formats.c @@ -30,16 +30,16 @@ test_cfmt_relay_header(void *arg) uint8_t hdr_out[RELAY_HEADER_SIZE]; (void)arg;

- tt_int_op(sizeof(hdr_1), ==, RELAY_HEADER_SIZE); + tt_int_op(sizeof(hdr_1), OP_EQ, RELAY_HEADER_SIZE); relay_header_unpack(&rh, hdr_1); - tt_int_op(rh.command, ==, 3); - tt_int_op(rh.recognized, ==, 0); - tt_int_op(rh.stream_id, ==, 0x2122); - tt_mem_op(rh.integrity, ==, "ABCD", 4); - tt_int_op(rh.length, ==, 0x103); + tt_int_op(rh.command, OP_EQ, 3); + tt_int_op(rh.recognized, OP_EQ, 0); + tt_int_op(rh.stream_id, OP_EQ, 0x2122); + tt_mem_op(rh.integrity, OP_EQ, "ABCD", 4); + tt_int_op(rh.length, OP_EQ, 0x103);

relay_header_pack(hdr_out, &rh); - tt_mem_op(hdr_out, ==, hdr_1, RELAY_HEADER_SIZE); + tt_mem_op(hdr_out, OP_EQ, hdr_1, RELAY_HEADER_SIZE);

done: ; @@ -74,32 +74,32 @@ test_cfmt_begin_cells(void *arg) /* Try begindir. */ memset(&bcell, 0x7f, sizeof(bcell)); make_relay_cell(&cell, RELAY_COMMAND_BEGIN_DIR, "", 0); - tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason)); - tt_ptr_op(NULL, ==, bcell.address); - tt_int_op(0, ==, bcell.flags); - tt_int_op(0, ==, bcell.port); - tt_int_op(5, ==, bcell.stream_id); - tt_int_op(1, ==, bcell.is_begindir); + tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_ptr_op(NULL, OP_EQ, bcell.address); + tt_int_op(0, OP_EQ, bcell.flags); + tt_int_op(0, OP_EQ, bcell.port); + tt_int_op(5, OP_EQ, bcell.stream_id); + tt_int_op(1, OP_EQ, bcell.is_begindir);

/* A Begindir with extra stuff. */ memset(&bcell, 0x7f, sizeof(bcell)); make_relay_cell(&cell, RELAY_COMMAND_BEGIN_DIR, "12345", 5); - tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason)); - tt_ptr_op(NULL, ==, bcell.address); - tt_int_op(0, ==, bcell.flags); - tt_int_op(0, ==, bcell.port); - tt_int_op(5, ==, bcell.stream_id); - tt_int_op(1, ==, bcell.is_begindir); + tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_ptr_op(NULL, OP_EQ, bcell.address); + tt_int_op(0, OP_EQ, bcell.flags); + tt_int_op(0, OP_EQ, bcell.port); + tt_int_op(5, OP_EQ, bcell.stream_id); + tt_int_op(1, OP_EQ, bcell.is_begindir);

/* A short but valid begin cell */ memset(&bcell, 0x7f, sizeof(bcell)); make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "a.b:9", 6); - tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason)); - tt_str_op("a.b", ==, bcell.address); - tt_int_op(0, ==, bcell.flags); - tt_int_op(9, ==, bcell.port); - tt_int_op(5, ==, bcell.stream_id); - tt_int_op(0, ==, bcell.is_begindir); + tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_str_op("a.b", OP_EQ, bcell.address); + tt_int_op(0, OP_EQ, bcell.flags); + tt_int_op(9, OP_EQ, bcell.port); + tt_int_op(5, OP_EQ, bcell.stream_id); + tt_int_op(0, OP_EQ, bcell.is_begindir); tor_free(bcell.address);

/* A significantly loner begin cell */ @@ -108,35 +108,35 @@ test_cfmt_begin_cells(void *arg) const char c[] = "here-is-a-nice-long.hostname.com:65535"; make_relay_cell(&cell, RELAY_COMMAND_BEGIN, c, strlen(c)+1); } - tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason)); - tt_str_op("here-is-a-nice-long.hostname.com", ==, bcell.address); - tt_int_op(0, ==, bcell.flags); - tt_int_op(65535, ==, bcell.port); - tt_int_op(5, ==, bcell.stream_id); - tt_int_op(0, ==, bcell.is_begindir); + tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_str_op("here-is-a-nice-long.hostname.com", OP_EQ, bcell.address); + tt_int_op(0, OP_EQ, bcell.flags); + tt_int_op(65535, OP_EQ, bcell.port); + tt_int_op(5, OP_EQ, bcell.stream_id); + tt_int_op(0, OP_EQ, bcell.is_begindir); tor_free(bcell.address);

/* An IPv4 begin cell. */ memset(&bcell, 0x7f, sizeof(bcell)); make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "18.9.22.169:80", 15); - tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason)); - tt_str_op("18.9.22.169", ==, bcell.address); - tt_int_op(0, ==, bcell.flags); - tt_int_op(80, ==, bcell.port); - tt_int_op(5, ==, bcell.stream_id); - tt_int_op(0, ==, bcell.is_begindir); + tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_str_op("18.9.22.169", OP_EQ, bcell.address); + tt_int_op(0, OP_EQ, bcell.flags); + tt_int_op(80, OP_EQ, bcell.port); + tt_int_op(5, OP_EQ, bcell.stream_id); + tt_int_op(0, OP_EQ, bcell.is_begindir); tor_free(bcell.address);

/* An IPv6 begin cell. Let's make sure we handle colons*/ memset(&bcell, 0x7f, sizeof(bcell)); make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "[2620::6b0:b:1a1a:0:26e5:480e]:80", 34); - tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason)); - tt_str_op("[2620::6b0:b:1a1a:0:26e5:480e]", ==, bcell.address); - tt_int_op(0, ==, bcell.flags); - tt_int_op(80, ==, bcell.port); - tt_int_op(5, ==, bcell.stream_id); - tt_int_op(0, ==, bcell.is_begindir); + tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_str_op("[2620::6b0:b:1a1a:0:26e5:480e]", OP_EQ, bcell.address); + tt_int_op(0, OP_EQ, bcell.flags); + tt_int_op(80, OP_EQ, bcell.port); + tt_int_op(5, OP_EQ, bcell.stream_id); + tt_int_op(0, OP_EQ, bcell.is_begindir); tor_free(bcell.address);

/* a begin cell with extra junk but not enough for flags. */ @@ -145,12 +145,12 @@ test_cfmt_begin_cells(void *arg) const char c[] = "another.example.com:80\x00\x01\x02"; make_relay_cell(&cell, RELAY_COMMAND_BEGIN, c, sizeof(c)-1); } - tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason)); - tt_str_op("another.example.com", ==, bcell.address); - tt_int_op(0, ==, bcell.flags); - tt_int_op(80, ==, bcell.port); - tt_int_op(5, ==, bcell.stream_id); - tt_int_op(0, ==, bcell.is_begindir); + tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_str_op("another.example.com", OP_EQ, bcell.address); + tt_int_op(0, OP_EQ, bcell.flags); + tt_int_op(80, OP_EQ, bcell.port); + tt_int_op(5, OP_EQ, bcell.stream_id); + tt_int_op(0, OP_EQ, bcell.is_begindir); tor_free(bcell.address);

/* a begin cell with flags. */ @@ -159,12 +159,12 @@ test_cfmt_begin_cells(void *arg) const char c[] = "another.example.com:443\x00\x01\x02\x03\x04"; make_relay_cell(&cell, RELAY_COMMAND_BEGIN, c, sizeof(c)-1); } - tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason)); - tt_str_op("another.example.com", ==, bcell.address); - tt_int_op(0x1020304, ==, bcell.flags); - tt_int_op(443, ==, bcell.port); - tt_int_op(5, ==, bcell.stream_id); - tt_int_op(0, ==, bcell.is_begindir); + tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_str_op("another.example.com", OP_EQ, bcell.address); + tt_int_op(0x1020304, OP_EQ, bcell.flags); + tt_int_op(443, OP_EQ, bcell.port); + tt_int_op(5, OP_EQ, bcell.stream_id); + tt_int_op(0, OP_EQ, bcell.is_begindir); tor_free(bcell.address);

/* a begin cell with flags and even more cruft after that. */ @@ -173,12 +173,12 @@ test_cfmt_begin_cells(void *arg) const char c[] = "a-further.example.com:22\x00\xee\xaa\x00\xffHi mom"; make_relay_cell(&cell, RELAY_COMMAND_BEGIN, c, sizeof(c)-1); } - tt_int_op(0, ==, begin_cell_parse(&cell, &bcell, &end_reason)); - tt_str_op("a-further.example.com", ==, bcell.address); - tt_int_op(0xeeaa00ff, ==, bcell.flags); - tt_int_op(22, ==, bcell.port); - tt_int_op(5, ==, bcell.stream_id); - tt_int_op(0, ==, bcell.is_begindir); + tt_int_op(0, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_str_op("a-further.example.com", OP_EQ, bcell.address); + tt_int_op(0xeeaa00ff, OP_EQ, bcell.flags); + tt_int_op(22, OP_EQ, bcell.port); + tt_int_op(5, OP_EQ, bcell.stream_id); + tt_int_op(0, OP_EQ, bcell.is_begindir); tor_free(bcell.address);

/* bad begin cell: impossible length. */ @@ -189,42 +189,42 @@ test_cfmt_begin_cells(void *arg) { relay_header_t rh; relay_header_unpack(&rh, cell.payload); - tt_int_op(rh.length, ==, 510); + tt_int_op(rh.length, OP_EQ, 510); } - tt_int_op(-2, ==, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_int_op(-2, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));

/* Bad begin cell: no body. */ memset(&bcell, 0x7f, sizeof(bcell)); make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "", 0); - tt_int_op(-1, ==, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_int_op(-1, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));

/* bad begin cell: no body. */ memset(&bcell, 0x7f, sizeof(bcell)); make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "", 0); - tt_int_op(-1, ==, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_int_op(-1, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));

/* bad begin cell: no colon */ memset(&bcell, 0x7f, sizeof(bcell)); make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "a.b", 4); - tt_int_op(-1, ==, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_int_op(-1, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));

/* bad begin cell: no ports */ memset(&bcell, 0x7f, sizeof(bcell)); make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "a.b:", 5); - tt_int_op(-1, ==, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_int_op(-1, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));

/* bad begin cell: bad port */ memset(&bcell, 0x7f, sizeof(bcell)); make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "a.b:xyz", 8); - tt_int_op(-1, ==, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_int_op(-1, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason)); memset(&bcell, 0x7f, sizeof(bcell)); make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "a.b:100000", 11); - tt_int_op(-1, ==, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_int_op(-1, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));

/* bad begin cell: no nul */ memset(&bcell, 0x7f, sizeof(bcell)); make_relay_cell(&cell, RELAY_COMMAND_BEGIN, "a.b:80", 6); - tt_int_op(-1, ==, begin_cell_parse(&cell, &bcell, &end_reason)); + tt_int_op(-1, OP_EQ, begin_cell_parse(&cell, &bcell, &end_reason));

done: tor_free(bcell.address); @@ -244,47 +244,47 @@ test_cfmt_connected_cells(void *arg) make_relay_cell(&cell, RELAY_COMMAND_CONNECTED, "", 0); relay_header_unpack(&rh, cell.payload); r = connected_cell_parse(&rh, &cell, &addr, &ttl); - tt_int_op(r, ==, 0); - tt_int_op(tor_addr_family(&addr), ==, AF_UNSPEC); - tt_int_op(ttl, ==, -1); + tt_int_op(r, OP_EQ, 0); + tt_int_op(tor_addr_family(&addr), OP_EQ, AF_UNSPEC); + tt_int_op(ttl, OP_EQ, -1);

/* A slightly less oldschool one: only an IPv4 address */ make_relay_cell(&cell, RELAY_COMMAND_CONNECTED, "\x20\x30\x40\x50", 4); relay_header_unpack(&rh, cell.payload); r = connected_cell_parse(&rh, &cell, &addr, &ttl); - tt_int_op(r, ==, 0); - tt_int_op(tor_addr_family(&addr), ==, AF_INET); - tt_str_op(fmt_addr(&addr), ==, "32.48.64.80"); - tt_int_op(ttl, ==, -1); + tt_int_op(r, OP_EQ, 0); + tt_int_op(tor_addr_family(&addr), OP_EQ, AF_INET); + tt_str_op(fmt_addr(&addr), OP_EQ, "32.48.64.80"); + tt_int_op(ttl, OP_EQ, -1);

/* Bogus but understandable: truncated TTL */ make_relay_cell(&cell, RELAY_COMMAND_CONNECTED, "\x11\x12\x13\x14\x15", 5); relay_header_unpack(&rh, cell.payload); r = connected_cell_parse(&rh, &cell, &addr, &ttl); - tt_int_op(r, ==, 0); - tt_int_op(tor_addr_family(&addr), ==, AF_INET); - tt_str_op(fmt_addr(&addr), ==, "17.18.19.20"); - tt_int_op(ttl, ==, -1); + tt_int_op(r, OP_EQ, 0); + tt_int_op(tor_addr_family(&addr), OP_EQ, AF_INET); + tt_str_op(fmt_addr(&addr), OP_EQ, "17.18.19.20"); + tt_int_op(ttl, OP_EQ, -1);

/* Regular IPv4 one: address and TTL */ make_relay_cell(&cell, RELAY_COMMAND_CONNECTED, "\x02\x03\x04\x05\x00\x00\x0e\x10", 8); relay_header_unpack(&rh, cell.payload); r = connected_cell_parse(&rh, &cell, &addr, &ttl); - tt_int_op(r, ==, 0); - tt_int_op(tor_addr_family(&addr), ==, AF_INET); - tt_str_op(fmt_addr(&addr), ==, "2.3.4.5"); - tt_int_op(ttl, ==, 3600); + tt_int_op(r, OP_EQ, 0); + tt_int_op(tor_addr_family(&addr), OP_EQ, AF_INET); + tt_str_op(fmt_addr(&addr), OP_EQ, "2.3.4.5"); + tt_int_op(ttl, OP_EQ, 3600);

/* IPv4 with too-big TTL */ make_relay_cell(&cell, RELAY_COMMAND_CONNECTED, "\x02\x03\x04\x05\xf0\x00\x00\x00", 8); relay_header_unpack(&rh, cell.payload); r = connected_cell_parse(&rh, &cell, &addr, &ttl); - tt_int_op(r, ==, 0); - tt_int_op(tor_addr_family(&addr), ==, AF_INET); - tt_str_op(fmt_addr(&addr), ==, "2.3.4.5"); - tt_int_op(ttl, ==, -1); + tt_int_op(r, OP_EQ, 0); + tt_int_op(tor_addr_family(&addr), OP_EQ, AF_INET); + tt_str_op(fmt_addr(&addr), OP_EQ, "2.3.4.5"); + tt_int_op(ttl, OP_EQ, -1);

/* IPv6 (ttl is mandatory) */ make_relay_cell(&cell, RELAY_COMMAND_CONNECTED, @@ -294,10 +294,10 @@ test_cfmt_connected_cells(void *arg) "\x00\x00\x02\x58", 25); relay_header_unpack(&rh, cell.payload); r = connected_cell_parse(&rh, &cell, &addr, &ttl); - tt_int_op(r, ==, 0); - tt_int_op(tor_addr_family(&addr), ==, AF_INET6); - tt_str_op(fmt_addr(&addr), ==, "2607:f8b0:400c:c02::68"); - tt_int_op(ttl, ==, 600); + tt_int_op(r, OP_EQ, 0); + tt_int_op(tor_addr_family(&addr), OP_EQ, AF_INET6); + tt_str_op(fmt_addr(&addr), OP_EQ, "2607:f8b0:400c:c02::68"); + tt_int_op(ttl, OP_EQ, 600);

/* IPv6 (ttl too big) */ make_relay_cell(&cell, RELAY_COMMAND_CONNECTED, @@ -307,17 +307,17 @@ test_cfmt_connected_cells(void *arg) "\x90\x00\x02\x58", 25); relay_header_unpack(&rh, cell.payload); r = connected_cell_parse(&rh, &cell, &addr, &ttl); - tt_int_op(r, ==, 0); - tt_int_op(tor_addr_family(&addr), ==, AF_INET6); - tt_str_op(fmt_addr(&addr), ==, "2607:f8b0:400c:c02::68"); - tt_int_op(ttl, ==, -1); + tt_int_op(r, OP_EQ, 0); + tt_int_op(tor_addr_family(&addr), OP_EQ, AF_INET6); + tt_str_op(fmt_addr(&addr), OP_EQ, "2607:f8b0:400c:c02::68"); + tt_int_op(ttl, OP_EQ, -1);

/* Bogus size: 3. */ make_relay_cell(&cell, RELAY_COMMAND_CONNECTED, "\x00\x01\x02", 3); relay_header_unpack(&rh, cell.payload); r = connected_cell_parse(&rh, &cell, &addr, &ttl); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1);

/* Bogus family: 7. */ make_relay_cell(&cell, RELAY_COMMAND_CONNECTED, @@ -327,7 +327,7 @@ test_cfmt_connected_cells(void *arg) "\x90\x00\x02\x58", 25); relay_header_unpack(&rh, cell.payload); r = connected_cell_parse(&rh, &cell, &addr, &ttl); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1);

/* Truncated IPv6. */ make_relay_cell(&cell, RELAY_COMMAND_CONNECTED, @@ -337,7 +337,7 @@ test_cfmt_connected_cells(void *arg) "\x00\x00\x02", 24); relay_header_unpack(&rh, cell.payload); r = connected_cell_parse(&rh, &cell, &addr, &ttl); - tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1);

/* Now make sure we can generate connected cells correctly. */ /* Try an IPv4 address */ @@ -346,16 +346,16 @@ test_cfmt_connected_cells(void *arg) tor_addr_parse(&addr, "30.40.50.60"); rh.length = connected_cell_format_payload(cell.payload+RELAY_HEADER_SIZE, &addr, 128); - tt_int_op(rh.length, ==, 8); + tt_int_op(rh.length, OP_EQ, 8); test_memeq_hex(cell.payload+RELAY_HEADER_SIZE, "1e28323c" "00000080");

/* Try parsing it. */ tor_addr_make_unspec(&addr); r = connected_cell_parse(&rh, &cell, &addr, &ttl); - tt_int_op(r, ==, 0); - tt_int_op(tor_addr_family(&addr), ==, AF_INET); - tt_str_op(fmt_addr(&addr), ==, "30.40.50.60"); - tt_int_op(ttl, ==, 128); + tt_int_op(r, OP_EQ, 0); + tt_int_op(tor_addr_family(&addr), OP_EQ, AF_INET); + tt_str_op(fmt_addr(&addr), OP_EQ, "30.40.50.60"); + tt_int_op(ttl, OP_EQ, 128);

/* Try an IPv6 address */ memset(&rh, 0, sizeof(rh)); @@ -363,7 +363,7 @@ test_cfmt_connected_cells(void *arg) tor_addr_parse(&addr, "2620::6b0:b:1a1a:0:26e5:480e"); rh.length = connected_cell_format_payload(cell.payload+RELAY_HEADER_SIZE, &addr, 3600); - tt_int_op(rh.length, ==, 25); + tt_int_op(rh.length, OP_EQ, 25); test_memeq_hex(cell.payload + RELAY_HEADER_SIZE, "00000000" "06" "2620000006b0000b1a1a000026e5480e" "00000e10"); @@ -371,10 +371,10 @@ test_cfmt_connected_cells(void *arg) /* Try parsing it. */ tor_addr_make_unspec(&addr); r = connected_cell_parse(&rh, &cell, &addr, &ttl); - tt_int_op(r, ==, 0); - tt_int_op(tor_addr_family(&addr), ==, AF_INET6); - tt_str_op(fmt_addr(&addr), ==, "2620:0:6b0:b:1a1a:0:26e5:480e"); - tt_int_op(ttl, ==, 3600); + tt_int_op(r, OP_EQ, 0); + tt_int_op(tor_addr_family(&addr), OP_EQ, AF_INET6); + tt_str_op(fmt_addr(&addr), OP_EQ, "2620:0:6b0:b:1a1a:0:26e5:480e"); + tt_int_op(ttl, OP_EQ, 3600);

done: tor_free(mem_op_hex_tmp); @@ -398,14 +398,14 @@ test_cfmt_create_cells(void *arg) crypto_rand((char*)b, TAP_ONIONSKIN_CHALLENGE_LEN); cell.command = CELL_CREATE; memcpy(cell.payload, b, TAP_ONIONSKIN_CHALLENGE_LEN); - tt_int_op(0, ==, create_cell_parse(&cc, &cell)); - tt_int_op(CELL_CREATE, ==, cc.cell_type); - tt_int_op(ONION_HANDSHAKE_TYPE_TAP, ==, cc.handshake_type); - tt_int_op(TAP_ONIONSKIN_CHALLENGE_LEN, ==, cc.handshake_len); - tt_mem_op(cc.onionskin,==, b, TAP_ONIONSKIN_CHALLENGE_LEN + 10); - tt_int_op(0, ==, create_cell_format(&cell2, &cc)); - tt_int_op(cell.command, ==, cell2.command); - tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE); + tt_int_op(0, OP_EQ, create_cell_parse(&cc, &cell)); + tt_int_op(CELL_CREATE, OP_EQ, cc.cell_type); + tt_int_op(ONION_HANDSHAKE_TYPE_TAP, OP_EQ, cc.handshake_type); + tt_int_op(TAP_ONIONSKIN_CHALLENGE_LEN, OP_EQ, cc.handshake_len); + tt_mem_op(cc.onionskin,OP_EQ, b, TAP_ONIONSKIN_CHALLENGE_LEN + 10); + tt_int_op(0, OP_EQ, create_cell_format(&cell2, &cc)); + tt_int_op(cell.command, OP_EQ, cell2.command); + tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);

/* A valid create_fast cell. */ memset(&cell, 0, sizeof(cell)); @@ -413,14 +413,14 @@ test_cfmt_create_cells(void *arg) crypto_rand((char*)b, CREATE_FAST_LEN); cell.command = CELL_CREATE_FAST; memcpy(cell.payload, b, CREATE_FAST_LEN); - tt_int_op(0, ==, create_cell_parse(&cc, &cell)); - tt_int_op(CELL_CREATE_FAST, ==, cc.cell_type); - tt_int_op(ONION_HANDSHAKE_TYPE_FAST, ==, cc.handshake_type); - tt_int_op(CREATE_FAST_LEN, ==, cc.handshake_len); - tt_mem_op(cc.onionskin,==, b, CREATE_FAST_LEN + 10); - tt_int_op(0, ==, create_cell_format(&cell2, &cc)); - tt_int_op(cell.command, ==, cell2.command); - tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE); + tt_int_op(0, OP_EQ, create_cell_parse(&cc, &cell)); + tt_int_op(CELL_CREATE_FAST, OP_EQ, cc.cell_type); + tt_int_op(ONION_HANDSHAKE_TYPE_FAST, OP_EQ, cc.handshake_type); + tt_int_op(CREATE_FAST_LEN, OP_EQ, cc.handshake_len); + tt_mem_op(cc.onionskin,OP_EQ, b, CREATE_FAST_LEN + 10); + tt_int_op(0, OP_EQ, create_cell_format(&cell2, &cc)); + tt_int_op(cell.command, OP_EQ, cell2.command); + tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);

/* A valid create2 cell with a TAP payload */ memset(&cell, 0, sizeof(cell)); @@ -429,14 +429,14 @@ test_cfmt_create_cells(void *arg) cell.command = CELL_CREATE2; memcpy(cell.payload, "\x00\x00\x00\xBA", 4); /* TAP, 186 bytes long */ memcpy(cell.payload+4, b, TAP_ONIONSKIN_CHALLENGE_LEN); - tt_int_op(0, ==, create_cell_parse(&cc, &cell)); - tt_int_op(CELL_CREATE2, ==, cc.cell_type); - tt_int_op(ONION_HANDSHAKE_TYPE_TAP, ==, cc.handshake_type); - tt_int_op(TAP_ONIONSKIN_CHALLENGE_LEN, ==, cc.handshake_len); - tt_mem_op(cc.onionskin,==, b, TAP_ONIONSKIN_CHALLENGE_LEN + 10); - tt_int_op(0, ==, create_cell_format(&cell2, &cc)); - tt_int_op(cell.command, ==, cell2.command); - tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE); + tt_int_op(0, OP_EQ, create_cell_parse(&cc, &cell)); + tt_int_op(CELL_CREATE2, OP_EQ, cc.cell_type); + tt_int_op(ONION_HANDSHAKE_TYPE_TAP, OP_EQ, cc.handshake_type); + tt_int_op(TAP_ONIONSKIN_CHALLENGE_LEN, OP_EQ, cc.handshake_len); + tt_mem_op(cc.onionskin,OP_EQ, b, TAP_ONIONSKIN_CHALLENGE_LEN + 10); + tt_int_op(0, OP_EQ, create_cell_format(&cell2, &cc)); + tt_int_op(cell.command, OP_EQ, cell2.command); + tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);

/* A valid create2 cell with an ntor payload */ memset(&cell, 0, sizeof(cell)); @@ -445,14 +445,14 @@ test_cfmt_create_cells(void *arg) cell.command = CELL_CREATE2; memcpy(cell.payload, "\x00\x02\x00\x54", 4); /* ntor, 84 bytes long */ memcpy(cell.payload+4, b, NTOR_ONIONSKIN_LEN); - tt_int_op(0, ==, create_cell_parse(&cc, &cell)); - tt_int_op(CELL_CREATE2, ==, cc.cell_type); - tt_int_op(ONION_HANDSHAKE_TYPE_NTOR, ==, cc.handshake_type); - tt_int_op(NTOR_ONIONSKIN_LEN, ==, cc.handshake_len); - tt_mem_op(cc.onionskin,==, b, NTOR_ONIONSKIN_LEN + 10); - tt_int_op(0, ==, create_cell_format(&cell2, &cc)); - tt_int_op(cell.command, ==, cell2.command); - tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE); + tt_int_op(0, OP_EQ, create_cell_parse(&cc, &cell)); + tt_int_op(CELL_CREATE2, OP_EQ, cc.cell_type); + tt_int_op(ONION_HANDSHAKE_TYPE_NTOR, OP_EQ, cc.handshake_type); + tt_int_op(NTOR_ONIONSKIN_LEN, OP_EQ, cc.handshake_len); + tt_mem_op(cc.onionskin,OP_EQ, b, NTOR_ONIONSKIN_LEN + 10); + tt_int_op(0, OP_EQ, create_cell_format(&cell2, &cc)); + tt_int_op(cell.command, OP_EQ, cell2.command); + tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);

/* A valid create cell with an ntor payload, in legacy format. */ memset(&cell, 0, sizeof(cell)); @@ -461,38 +461,38 @@ test_cfmt_create_cells(void *arg) cell.command = CELL_CREATE; memcpy(cell.payload, "ntorNTORntorNTOR", 16); memcpy(cell.payload+16, b, NTOR_ONIONSKIN_LEN); - tt_int_op(0, ==, create_cell_parse(&cc, &cell)); - tt_int_op(CELL_CREATE, ==, cc.cell_type); - tt_int_op(ONION_HANDSHAKE_TYPE_NTOR, ==, cc.handshake_type); - tt_int_op(NTOR_ONIONSKIN_LEN, ==, cc.handshake_len); - tt_mem_op(cc.onionskin,==, b, NTOR_ONIONSKIN_LEN + 10); - tt_int_op(0, ==, create_cell_format(&cell2, &cc)); - tt_int_op(cell.command, ==, cell2.command); - tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE); + tt_int_op(0, OP_EQ, create_cell_parse(&cc, &cell)); + tt_int_op(CELL_CREATE, OP_EQ, cc.cell_type); + tt_int_op(ONION_HANDSHAKE_TYPE_NTOR, OP_EQ, cc.handshake_type); + tt_int_op(NTOR_ONIONSKIN_LEN, OP_EQ, cc.handshake_len); + tt_mem_op(cc.onionskin,OP_EQ, b, NTOR_ONIONSKIN_LEN + 10); + tt_int_op(0, OP_EQ, create_cell_format(&cell2, &cc)); + tt_int_op(cell.command, OP_EQ, cell2.command); + tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);

/* == Okay, now let's try to parse some impossible stuff. */

/* It has to be some kind of a create cell! */ cell.command = CELL_CREATED; - tt_int_op(-1, ==, create_cell_parse(&cc, &cell)); + tt_int_op(-1, OP_EQ, create_cell_parse(&cc, &cell));

/* You can't acutally make an unparseable CREATE or CREATE_FAST cell. */

/* Try some CREATE2 cells. First with a bad type. */ cell.command = CELL_CREATE2; memcpy(cell.payload, "\x00\x50\x00\x99", 4); /* Type 0x50???? */ - tt_int_op(-1, ==, create_cell_parse(&cc, &cell)); + tt_int_op(-1, OP_EQ, create_cell_parse(&cc, &cell)); /* Now a good type with an incorrect length. */ memcpy(cell.payload, "\x00\x00\x00\xBC", 4); /* TAP, 187 bytes.*/ - tt_int_op(-1, ==, create_cell_parse(&cc, &cell)); + tt_int_op(-1, OP_EQ, create_cell_parse(&cc, &cell)); /* Now a good type with a ridiculous length. */ memcpy(cell.payload, "\x00\x00\x02\x00", 4); /* TAP, 512 bytes.*/ - tt_int_op(-1, ==, create_cell_parse(&cc, &cell)); + tt_int_op(-1, OP_EQ, create_cell_parse(&cc, &cell));

/* == Time to try formatting bad cells. The important thing is that we reject big lengths, so just check that for now. */ cc.handshake_len = 512; - tt_int_op(-1, ==, create_cell_format(&cell2, &cc)); + tt_int_op(-1, OP_EQ, create_cell_format(&cell2, &cc));

/* == Try formatting a create2 cell we don't understand. XXXX */

@@ -516,13 +516,13 @@ test_cfmt_created_cells(void *arg) crypto_rand((char*)b, TAP_ONIONSKIN_REPLY_LEN); cell.command = CELL_CREATED; memcpy(cell.payload, b, TAP_ONIONSKIN_REPLY_LEN); - tt_int_op(0, ==, created_cell_parse(&cc, &cell)); - tt_int_op(CELL_CREATED, ==, cc.cell_type); - tt_int_op(TAP_ONIONSKIN_REPLY_LEN, ==, cc.handshake_len); - tt_mem_op(cc.reply,==, b, TAP_ONIONSKIN_REPLY_LEN + 10); - tt_int_op(0, ==, created_cell_format(&cell2, &cc)); - tt_int_op(cell.command, ==, cell2.command); - tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE); + tt_int_op(0, OP_EQ, created_cell_parse(&cc, &cell)); + tt_int_op(CELL_CREATED, OP_EQ, cc.cell_type); + tt_int_op(TAP_ONIONSKIN_REPLY_LEN, OP_EQ, cc.handshake_len); + tt_mem_op(cc.reply,OP_EQ, b, TAP_ONIONSKIN_REPLY_LEN + 10); + tt_int_op(0, OP_EQ, created_cell_format(&cell2, &cc)); + tt_int_op(cell.command, OP_EQ, cell2.command); + tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);

/* A good CREATED_FAST cell */ memset(&cell, 0, sizeof(cell)); @@ -530,13 +530,13 @@ test_cfmt_created_cells(void *arg) crypto_rand((char*)b, CREATED_FAST_LEN); cell.command = CELL_CREATED_FAST; memcpy(cell.payload, b, CREATED_FAST_LEN); - tt_int_op(0, ==, created_cell_parse(&cc, &cell)); - tt_int_op(CELL_CREATED_FAST, ==, cc.cell_type); - tt_int_op(CREATED_FAST_LEN, ==, cc.handshake_len); - tt_mem_op(cc.reply,==, b, CREATED_FAST_LEN + 10); - tt_int_op(0, ==, created_cell_format(&cell2, &cc)); - tt_int_op(cell.command, ==, cell2.command); - tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE); + tt_int_op(0, OP_EQ, created_cell_parse(&cc, &cell)); + tt_int_op(CELL_CREATED_FAST, OP_EQ, cc.cell_type); + tt_int_op(CREATED_FAST_LEN, OP_EQ, cc.handshake_len); + tt_mem_op(cc.reply,OP_EQ, b, CREATED_FAST_LEN + 10); + tt_int_op(0, OP_EQ, created_cell_format(&cell2, &cc)); + tt_int_op(cell.command, OP_EQ, cell2.command); + tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);

/* A good CREATED2 cell with short reply */ memset(&cell, 0, sizeof(cell)); @@ -545,13 +545,13 @@ test_cfmt_created_cells(void *arg) cell.command = CELL_CREATED2; memcpy(cell.payload, "\x00\x40", 2); memcpy(cell.payload+2, b, 64); - tt_int_op(0, ==, created_cell_parse(&cc, &cell)); - tt_int_op(CELL_CREATED2, ==, cc.cell_type); - tt_int_op(64, ==, cc.handshake_len); - tt_mem_op(cc.reply,==, b, 80); - tt_int_op(0, ==, created_cell_format(&cell2, &cc)); - tt_int_op(cell.command, ==, cell2.command); - tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE); + tt_int_op(0, OP_EQ, created_cell_parse(&cc, &cell)); + tt_int_op(CELL_CREATED2, OP_EQ, cc.cell_type); + tt_int_op(64, OP_EQ, cc.handshake_len); + tt_mem_op(cc.reply,OP_EQ, b, 80); + tt_int_op(0, OP_EQ, created_cell_format(&cell2, &cc)); + tt_int_op(cell.command, OP_EQ, cell2.command); + tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);

/* A good CREATED2 cell with maximal reply */ memset(&cell, 0, sizeof(cell)); @@ -560,13 +560,13 @@ test_cfmt_created_cells(void *arg) cell.command = CELL_CREATED2; memcpy(cell.payload, "\x01\xF0", 2); memcpy(cell.payload+2, b, 496); - tt_int_op(0, ==, created_cell_parse(&cc, &cell)); - tt_int_op(CELL_CREATED2, ==, cc.cell_type); - tt_int_op(496, ==, cc.handshake_len); - tt_mem_op(cc.reply,==, b, 496); - tt_int_op(0, ==, created_cell_format(&cell2, &cc)); - tt_int_op(cell.command, ==, cell2.command); - tt_mem_op(cell.payload,==, cell2.payload, CELL_PAYLOAD_SIZE); + tt_int_op(0, OP_EQ, created_cell_parse(&cc, &cell)); + tt_int_op(CELL_CREATED2, OP_EQ, cc.cell_type); + tt_int_op(496, OP_EQ, cc.handshake_len); + tt_mem_op(cc.reply,OP_EQ, b, 496); + tt_int_op(0, OP_EQ, created_cell_format(&cell2, &cc)); + tt_int_op(cell.command, OP_EQ, cell2.command); + tt_mem_op(cell.payload,OP_EQ, cell2.payload, CELL_PAYLOAD_SIZE);

/* Bogus CREATED2 cell: too long! */ memset(&cell, 0, sizeof(cell)); @@ -574,11 +574,11 @@ test_cfmt_created_cells(void *arg) crypto_rand((char*)b, 496); cell.command = CELL_CREATED2; memcpy(cell.payload, "\x01\xF1", 2); - tt_int_op(-1, ==, created_cell_parse(&cc, &cell)); + tt_int_op(-1, OP_EQ, created_cell_parse(&cc, &cell));

/* Unformattable CREATED2 cell: too long! */ cc.handshake_len = 497; - tt_int_op(-1, ==, created_cell_format(&cell2, &cc)); + tt_int_op(-1, OP_EQ, created_cell_format(&cell2, &cc));

done: ; @@ -606,21 +606,21 @@ test_cfmt_extend_cells(void *arg) memcpy(p, "\x12\xf4\x00\x01\x01\x02", 6); /* 18 244 0 1 : 258 */ memcpy(p+6,b,TAP_ONIONSKIN_CHALLENGE_LEN); memcpy(p+6+TAP_ONIONSKIN_CHALLENGE_LEN, "electroencephalogram", 20); - tt_int_op(0, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND, + tt_int_op(0, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND, p, 26+TAP_ONIONSKIN_CHALLENGE_LEN)); - tt_int_op(RELAY_COMMAND_EXTEND, ==, ec.cell_type); - tt_str_op("18.244.0.1", ==, fmt_addr(&ec.orport_ipv4.addr)); - tt_int_op(258, ==, ec.orport_ipv4.port); - tt_int_op(AF_UNSPEC, ==, tor_addr_family(&ec.orport_ipv6.addr)); - tt_mem_op(ec.node_id,==, "electroencephalogram", 20); - tt_int_op(cc->cell_type, ==, CELL_CREATE); - tt_int_op(cc->handshake_type, ==, ONION_HANDSHAKE_TYPE_TAP); - tt_int_op(cc->handshake_len, ==, TAP_ONIONSKIN_CHALLENGE_LEN); - tt_mem_op(cc->onionskin,==, b, TAP_ONIONSKIN_CHALLENGE_LEN+20); - tt_int_op(0, ==, extend_cell_format(&p2_cmd, &p2_len, p2, &ec)); - tt_int_op(p2_cmd, ==, RELAY_COMMAND_EXTEND); - tt_int_op(p2_len, ==, 26+TAP_ONIONSKIN_CHALLENGE_LEN); - tt_mem_op(p2,==, p, RELAY_PAYLOAD_SIZE); + tt_int_op(RELAY_COMMAND_EXTEND, OP_EQ, ec.cell_type); + tt_str_op("18.244.0.1", OP_EQ, fmt_addr(&ec.orport_ipv4.addr)); + tt_int_op(258, OP_EQ, ec.orport_ipv4.port); + tt_int_op(AF_UNSPEC, OP_EQ, tor_addr_family(&ec.orport_ipv6.addr)); + tt_mem_op(ec.node_id,OP_EQ, "electroencephalogram", 20); + tt_int_op(cc->cell_type, OP_EQ, CELL_CREATE); + tt_int_op(cc->handshake_type, OP_EQ, ONION_HANDSHAKE_TYPE_TAP); + tt_int_op(cc->handshake_len, OP_EQ, TAP_ONIONSKIN_CHALLENGE_LEN); + tt_mem_op(cc->onionskin,OP_EQ, b, TAP_ONIONSKIN_CHALLENGE_LEN+20); + tt_int_op(0, OP_EQ, extend_cell_format(&p2_cmd, &p2_len, p2, &ec)); + tt_int_op(p2_cmd, OP_EQ, RELAY_COMMAND_EXTEND); + tt_int_op(p2_len, OP_EQ, 26+TAP_ONIONSKIN_CHALLENGE_LEN); + tt_mem_op(p2,OP_EQ, p, RELAY_PAYLOAD_SIZE);

/* Let's do an ntor stuffed in a legacy EXTEND cell */ memset(p, 0, sizeof(p)); @@ -630,22 +630,22 @@ test_cfmt_extend_cells(void *arg) memcpy(p+6,"ntorNTORntorNTOR", 16); memcpy(p+22, b, NTOR_ONIONSKIN_LEN); memcpy(p+6+TAP_ONIONSKIN_CHALLENGE_LEN, "electroencephalogram", 20); - tt_int_op(0, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND, + tt_int_op(0, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND, p, 26+TAP_ONIONSKIN_CHALLENGE_LEN)); - tt_int_op(RELAY_COMMAND_EXTEND, ==, ec.cell_type); - tt_str_op("18.244.0.1", ==, fmt_addr(&ec.orport_ipv4.addr)); - tt_int_op(258, ==, ec.orport_ipv4.port); - tt_int_op(AF_UNSPEC, ==, tor_addr_family(&ec.orport_ipv6.addr)); - tt_mem_op(ec.node_id,==, "electroencephalogram", 20); - tt_int_op(cc->cell_type, ==, CELL_CREATE2); - tt_int_op(cc->handshake_type, ==, ONION_HANDSHAKE_TYPE_NTOR); - tt_int_op(cc->handshake_len, ==, NTOR_ONIONSKIN_LEN); - tt_mem_op(cc->onionskin,==, b, NTOR_ONIONSKIN_LEN+20); - tt_int_op(0, ==, extend_cell_format(&p2_cmd, &p2_len, p2, &ec)); - tt_int_op(p2_cmd, ==, RELAY_COMMAND_EXTEND); - tt_int_op(p2_len, ==, 26+TAP_ONIONSKIN_CHALLENGE_LEN); - tt_mem_op(p2,==, p, RELAY_PAYLOAD_SIZE); - tt_int_op(0, ==, create_cell_format_relayed(&cell, cc)); + tt_int_op(RELAY_COMMAND_EXTEND, OP_EQ, ec.cell_type); + tt_str_op("18.244.0.1", OP_EQ, fmt_addr(&ec.orport_ipv4.addr)); + tt_int_op(258, OP_EQ, ec.orport_ipv4.port); + tt_int_op(AF_UNSPEC, OP_EQ, tor_addr_family(&ec.orport_ipv6.addr)); + tt_mem_op(ec.node_id,OP_EQ, "electroencephalogram", 20); + tt_int_op(cc->cell_type, OP_EQ, CELL_CREATE2); + tt_int_op(cc->handshake_type, OP_EQ, ONION_HANDSHAKE_TYPE_NTOR); + tt_int_op(cc->handshake_len, OP_EQ, NTOR_ONIONSKIN_LEN); + tt_mem_op(cc->onionskin,OP_EQ, b, NTOR_ONIONSKIN_LEN+20); + tt_int_op(0, OP_EQ, extend_cell_format(&p2_cmd, &p2_len, p2, &ec)); + tt_int_op(p2_cmd, OP_EQ, RELAY_COMMAND_EXTEND); + tt_int_op(p2_len, OP_EQ, 26+TAP_ONIONSKIN_CHALLENGE_LEN); + tt_mem_op(p2,OP_EQ, p, RELAY_PAYLOAD_SIZE); + tt_int_op(0, OP_EQ, create_cell_format_relayed(&cell, cc));

/* Now let's do a minimal ntor EXTEND2 cell. */ memset(&ec, 0xff, sizeof(ec)); @@ -659,21 +659,21 @@ test_cfmt_extend_cells(void *arg) /* Prep for the handshake: type and length */ memcpy(p+31, "\x00\x02\x00\x54", 4); memcpy(p+35, b, NTOR_ONIONSKIN_LEN); - tt_int_op(0, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, + tt_int_op(0, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, p, 35+NTOR_ONIONSKIN_LEN)); - tt_int_op(RELAY_COMMAND_EXTEND2, ==, ec.cell_type); - tt_str_op("18.244.0.1", ==, fmt_addr(&ec.orport_ipv4.addr)); - tt_int_op(61681, ==, ec.orport_ipv4.port); - tt_int_op(AF_UNSPEC, ==, tor_addr_family(&ec.orport_ipv6.addr)); - tt_mem_op(ec.node_id,==, "anarchoindividualist", 20); - tt_int_op(cc->cell_type, ==, CELL_CREATE2); - tt_int_op(cc->handshake_type, ==, ONION_HANDSHAKE_TYPE_NTOR); - tt_int_op(cc->handshake_len, ==, NTOR_ONIONSKIN_LEN); - tt_mem_op(cc->onionskin,==, b, NTOR_ONIONSKIN_LEN+20); - tt_int_op(0, ==, extend_cell_format(&p2_cmd, &p2_len, p2, &ec)); - tt_int_op(p2_cmd, ==, RELAY_COMMAND_EXTEND2); - tt_int_op(p2_len, ==, 35+NTOR_ONIONSKIN_LEN); - tt_mem_op(p2,==, p, RELAY_PAYLOAD_SIZE); + tt_int_op(RELAY_COMMAND_EXTEND2, OP_EQ, ec.cell_type); + tt_str_op("18.244.0.1", OP_EQ, fmt_addr(&ec.orport_ipv4.addr)); + tt_int_op(61681, OP_EQ, ec.orport_ipv4.port); + tt_int_op(AF_UNSPEC, OP_EQ, tor_addr_family(&ec.orport_ipv6.addr)); + tt_mem_op(ec.node_id,OP_EQ, "anarchoindividualist", 20); + tt_int_op(cc->cell_type, OP_EQ, CELL_CREATE2); + tt_int_op(cc->handshake_type, OP_EQ, ONION_HANDSHAKE_TYPE_NTOR); + tt_int_op(cc->handshake_len, OP_EQ, NTOR_ONIONSKIN_LEN); + tt_mem_op(cc->onionskin,OP_EQ, b, NTOR_ONIONSKIN_LEN+20); + tt_int_op(0, OP_EQ, extend_cell_format(&p2_cmd, &p2_len, p2, &ec)); + tt_int_op(p2_cmd, OP_EQ, RELAY_COMMAND_EXTEND2); + tt_int_op(p2_len, OP_EQ, 35+NTOR_ONIONSKIN_LEN); + tt_mem_op(p2,OP_EQ, p, RELAY_PAYLOAD_SIZE);

/* Now let's do a fanciful EXTEND2 cell. */ memset(&ec, 0xff, sizeof(ec)); @@ -692,21 +692,21 @@ test_cfmt_extend_cells(void *arg) /* Prep for the handshake: weird type and length */ memcpy(p+85, "\x01\x05\x00\x63", 4); memcpy(p+89, b, 99); - tt_int_op(0, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, p, 89+99)); - tt_int_op(RELAY_COMMAND_EXTEND2, ==, ec.cell_type); - tt_str_op("18.244.0.1", ==, fmt_addr(&ec.orport_ipv4.addr)); - tt_int_op(61681, ==, ec.orport_ipv4.port); - tt_str_op("2002::f0:c51e", ==, fmt_addr(&ec.orport_ipv6.addr)); - tt_int_op(4370, ==, ec.orport_ipv6.port); - tt_mem_op(ec.node_id,==, "anthropomorphization", 20); - tt_int_op(cc->cell_type, ==, CELL_CREATE2); - tt_int_op(cc->handshake_type, ==, 0x105); - tt_int_op(cc->handshake_len, ==, 99); - tt_mem_op(cc->onionskin,==, b, 99+20); - tt_int_op(0, ==, extend_cell_format(&p2_cmd, &p2_len, p2, &ec)); - tt_int_op(p2_cmd, ==, RELAY_COMMAND_EXTEND2); + tt_int_op(0, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, p, 89+99)); + tt_int_op(RELAY_COMMAND_EXTEND2, OP_EQ, ec.cell_type); + tt_str_op("18.244.0.1", OP_EQ, fmt_addr(&ec.orport_ipv4.addr)); + tt_int_op(61681, OP_EQ, ec.orport_ipv4.port); + tt_str_op("2002::f0:c51e", OP_EQ, fmt_addr(&ec.orport_ipv6.addr)); + tt_int_op(4370, OP_EQ, ec.orport_ipv6.port); + tt_mem_op(ec.node_id,OP_EQ, "anthropomorphization", 20); + tt_int_op(cc->cell_type, OP_EQ, CELL_CREATE2); + tt_int_op(cc->handshake_type, OP_EQ, 0x105); + tt_int_op(cc->handshake_len, OP_EQ, 99); + tt_mem_op(cc->onionskin,OP_EQ, b, 99+20); + tt_int_op(0, OP_EQ, extend_cell_format(&p2_cmd, &p2_len, p2, &ec)); + tt_int_op(p2_cmd, OP_EQ, RELAY_COMMAND_EXTEND2); /* We'll generate it minus the IPv6 address and minus the konami code */ - tt_int_op(p2_len, ==, 89+99-34-20); + tt_int_op(p2_len, OP_EQ, 89+99-34-20); test_memeq_hex(p2, /* Two items: one that same darn IP address. */ "02000612F40001F0F1" @@ -714,8 +714,8 @@ test_cfmt_extend_cells(void *arg) "0214616e7468726f706f6d6f727068697a6174696f6e" /* Now the handshake prologue */ "01050063"); - tt_mem_op(p2+1+8+22+4,==, b, 99+20); - tt_int_op(0, ==, create_cell_format_relayed(&cell, cc)); + tt_mem_op(p2+1+8+22+4,OP_EQ, b, 99+20); + tt_int_op(0, OP_EQ, create_cell_format_relayed(&cell, cc));

/* == Now try parsing some junk */

@@ -724,7 +724,7 @@ test_cfmt_extend_cells(void *arg) memcpy(p, "\x02\x00\x06\x12\xf4\x00\x01\xf0\xf1", 9); memcpy(p+9, "\x02\x14" "anarchoindividualist", 22); memcpy(p+31, "\xff\xff\x01\xd0", 4); - tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, + tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, p, sizeof(p)));

/* Try two identities. */ @@ -733,14 +733,14 @@ test_cfmt_extend_cells(void *arg) memcpy(p+9, "\x02\x14" "anarchoindividualist", 22); memcpy(p+31, "\x02\x14" "autodepolymerization", 22); memcpy(p+53, "\xff\xff\x00\x10", 4); - tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, + tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, p, sizeof(p)));

/* No identities. */ memset(p, 0, sizeof(p)); memcpy(p, "\x01\x00\x06\x12\xf4\x00\x01\xf0\xf1", 9); memcpy(p+53, "\xff\xff\x00\x10", 4); - tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, + tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, p, sizeof(p)));

/* Try a bad IPv4 address (too long, too short)*/ @@ -748,13 +748,13 @@ test_cfmt_extend_cells(void *arg) memcpy(p, "\x02\x00\x07\x12\xf4\x00\x01\xf0\xf1\xff", 10); memcpy(p+10, "\x02\x14" "anarchoindividualist", 22); memcpy(p+32, "\xff\xff\x00\x10", 4); - tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, + tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, p, sizeof(p))); memset(p, 0, sizeof(p)); memcpy(p, "\x02\x00\x05\x12\xf4\x00\x01\xf0", 8); memcpy(p+8, "\x02\x14" "anarchoindividualist", 22); memcpy(p+30, "\xff\xff\x00\x10", 4); - tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, + tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, p, sizeof(p)));

/* IPv6 address (too long, too short, no IPv4)*/ @@ -763,28 +763,28 @@ test_cfmt_extend_cells(void *arg) memcpy(p+9, "\x02\x14" "anarchoindividualist", 22); memcpy(p+31, "\x01\x13" "xxxxxxxxxxxxxxxxYYZ", 19); memcpy(p+50, "\xff\xff\x00\x20", 4); - tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, + tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, p, sizeof(p))); memset(p, 0, sizeof(p)); memcpy(p, "\x03\x00\x06\x12\xf4\x00\x01\xf0\xf1", 9); memcpy(p+9, "\x02\x14" "anarchoindividualist", 22); memcpy(p+31, "\x01\x11" "xxxxxxxxxxxxxxxxY", 17); memcpy(p+48, "\xff\xff\x00\x20", 4); - tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, + tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, p, sizeof(p))); memset(p, 0, sizeof(p)); memcpy(p, "\x02", 1); memcpy(p+1, "\x02\x14" "anarchoindividualist", 22); memcpy(p+23, "\x01\x12" "xxxxxxxxxxxxxxxxYY", 18); memcpy(p+41, "\xff\xff\x00\x20", 4); - tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, + tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, p, sizeof(p)));

/* Running out of space in specifiers */ memset(p,0,sizeof(p)); memcpy(p, "\x05\x0a\xff", 3); memcpy(p+3+255, "\x0a\xff", 2); - tt_int_op(-1, ==, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, + tt_int_op(-1, OP_EQ, extend_cell_parse(&ec, RELAY_COMMAND_EXTEND2, p, sizeof(p)));

/* Fuzz, because why not. */ @@ -823,16 +823,16 @@ test_cfmt_extended_cells(void *arg) memset(b, 0, sizeof(b)); crypto_rand((char*)b, TAP_ONIONSKIN_REPLY_LEN); memcpy(p,b,TAP_ONIONSKIN_REPLY_LEN); - tt_int_op(0, ==, extended_cell_parse(&ec, RELAY_COMMAND_EXTENDED, p, + tt_int_op(0, OP_EQ, extended_cell_parse(&ec, RELAY_COMMAND_EXTENDED, p, TAP_ONIONSKIN_REPLY_LEN)); - tt_int_op(RELAY_COMMAND_EXTENDED, ==, ec.cell_type); - tt_int_op(cc->cell_type, ==, CELL_CREATED); - tt_int_op(cc->handshake_len, ==, TAP_ONIONSKIN_REPLY_LEN); - tt_mem_op(cc->reply,==, b, TAP_ONIONSKIN_REPLY_LEN); - tt_int_op(0, ==, extended_cell_format(&p2_cmd, &p2_len, p2, &ec)); - tt_int_op(RELAY_COMMAND_EXTENDED, ==, p2_cmd); - tt_int_op(TAP_ONIONSKIN_REPLY_LEN, ==, p2_len); - tt_mem_op(p2,==, p, sizeof(p2)); + tt_int_op(RELAY_COMMAND_EXTENDED, OP_EQ, ec.cell_type); + tt_int_op(cc->cell_type, OP_EQ, CELL_CREATED); + tt_int_op(cc->handshake_len, OP_EQ, TAP_ONIONSKIN_REPLY_LEN); + tt_mem_op(cc->reply,OP_EQ, b, TAP_ONIONSKIN_REPLY_LEN); + tt_int_op(0, OP_EQ, extended_cell_format(&p2_cmd, &p2_len, p2, &ec)); + tt_int_op(RELAY_COMMAND_EXTENDED, OP_EQ, p2_cmd); + tt_int_op(TAP_ONIONSKIN_REPLY_LEN, OP_EQ, p2_len); + tt_mem_op(p2,OP_EQ, p, sizeof(p2));

/* Try an EXTENDED2 cell */ memset(&ec, 0xff, sizeof(ec)); @@ -841,25 +841,25 @@ test_cfmt_extended_cells(void *arg) crypto_rand((char*)b, 42); memcpy(p,"\x00\x2a",2); memcpy(p+2,b,42); - tt_int_op(0, ==, extended_cell_parse(&ec, RELAY_COMMAND_EXTENDED2, p, 2+42)); - tt_int_op(RELAY_COMMAND_EXTENDED2, ==, ec.cell_type); - tt_int_op(cc->cell_type, ==, CELL_CREATED2); - tt_int_op(cc->handshake_len, ==, 42); - tt_mem_op(cc->reply,==, b, 42+10); - tt_int_op(0, ==, extended_cell_format(&p2_cmd, &p2_len, p2, &ec)); - tt_int_op(RELAY_COMMAND_EXTENDED2, ==, p2_cmd); - tt_int_op(2+42, ==, p2_len); - tt_mem_op(p2,==, p, sizeof(p2)); + tt_int_op(0, OP_EQ, extended_cell_parse(&ec, RELAY_COMMAND_EXTENDED2, p, 2+42)); + tt_int_op(RELAY_COMMAND_EXTENDED2, OP_EQ, ec.cell_type); + tt_int_op(cc->cell_type, OP_EQ, CELL_CREATED2); + tt_int_op(cc->handshake_len, OP_EQ, 42); + tt_mem_op(cc->reply,OP_EQ, b, 42+10); + tt_int_op(0, OP_EQ, extended_cell_format(&p2_cmd, &p2_len, p2, &ec)); + tt_int_op(RELAY_COMMAND_EXTENDED2, OP_EQ, p2_cmd); + tt_int_op(2+42, OP_EQ, p2_len); + tt_mem_op(p2,OP_EQ, p, sizeof(p2));

/* Try an almost-too-long EXTENDED2 cell */ memcpy(p, "\x01\xf0", 2); - tt_int_op(0, ==, + tt_int_op(0, OP_EQ, extended_cell_parse(&ec, RELAY_COMMAND_EXTENDED2, p, sizeof(p)));

/* Now try a too-long extended2 cell. That's the only misparse I can think * of. */ memcpy(p, "\x01\xf1", 2); - tt_int_op(-1, ==, + tt_int_op(-1, OP_EQ, extended_cell_parse(&ec, RELAY_COMMAND_EXTENDED2, p, sizeof(p)));

done: @@ -903,22 +903,22 @@ test_cfmt_resolved_cells(void *arg) /* Let's try an empty cell */ SET_CELL(""); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, 0); - tt_int_op(r, ==, 0); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(errcode, OP_EQ, 0); + tt_int_op(r, OP_EQ, 0); + tt_int_op(smartlist_len(addrs), OP_EQ, 0); CLEAR_ADDRS(); /* redundant but let's be consistent */

/* Cell with one ipv4 addr */ SET_CELL("\x04\x04" "\x7f\x00\x02\x0a" "\x00\00\x01\x00"); - tt_int_op(rh.length, ==, 10); + tt_int_op(rh.length, OP_EQ, 10); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, 0); - tt_int_op(r, ==, 0); - tt_int_op(smartlist_len(addrs), ==, 1); + tt_int_op(errcode, OP_EQ, 0); + tt_int_op(r, OP_EQ, 0); + tt_int_op(smartlist_len(addrs), OP_EQ, 1); a = smartlist_get(addrs, 0); - tt_str_op(fmt_addr(&a->addr), ==, "127.0.2.10"); - tt_ptr_op(a->hostname, ==, NULL); - tt_int_op(a->ttl, ==, 256); + tt_str_op(fmt_addr(&a->addr), OP_EQ, "127.0.2.10"); + tt_ptr_op(a->hostname, OP_EQ, NULL); + tt_int_op(a->ttl, OP_EQ, 256); CLEAR_ADDRS();

/* Cell with one ipv6 addr */ @@ -926,30 +926,30 @@ test_cfmt_resolved_cells(void *arg) "\x20\x02\x90\x90\x00\x00\x00\x00" "\x00\x00\x00\x00\xf0\xf0\xab\xcd" "\x02\00\x00\x01"); - tt_int_op(rh.length, ==, 22); + tt_int_op(rh.length, OP_EQ, 22); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, 0); - tt_int_op(r, ==, 0); - tt_int_op(smartlist_len(addrs), ==, 1); + tt_int_op(errcode, OP_EQ, 0); + tt_int_op(r, OP_EQ, 0); + tt_int_op(smartlist_len(addrs), OP_EQ, 1); a = smartlist_get(addrs, 0); - tt_str_op(fmt_addr(&a->addr), ==, "2002:9090::f0f0:abcd"); - tt_ptr_op(a->hostname, ==, NULL); - tt_int_op(a->ttl, ==, 0x2000001); + tt_str_op(fmt_addr(&a->addr), OP_EQ, "2002:9090::f0f0:abcd"); + tt_ptr_op(a->hostname, OP_EQ, NULL); + tt_int_op(a->ttl, OP_EQ, 0x2000001); CLEAR_ADDRS();

/* Cell with one hostname */ SET_CELL("\x00\x11" "motherbrain.zebes" "\x00\00\x00\x00"); - tt_int_op(rh.length, ==, 23); + tt_int_op(rh.length, OP_EQ, 23); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, 0); - tt_int_op(r, ==, 0); - tt_int_op(smartlist_len(addrs), ==, 1); + tt_int_op(errcode, OP_EQ, 0); + tt_int_op(r, OP_EQ, 0); + tt_int_op(smartlist_len(addrs), OP_EQ, 1); a = smartlist_get(addrs, 0); tt_assert(tor_addr_is_null(&a->addr)); - tt_str_op(a->hostname, ==, "motherbrain.zebes"); - tt_int_op(a->ttl, ==, 0); + tt_str_op(a->hostname, OP_EQ, "motherbrain.zebes"); + tt_int_op(a->ttl, OP_EQ, 0); CLEAR_ADDRS();

#define LONG_NAME \ @@ -958,51 +958,51 @@ test_cfmt_resolved_cells(void *arg) "function-is-already-very-full.of-copy-and-pasted-stuff.having-this-app" \ "ear-more-than-once-would-bother-me-somehow.is"

- tt_int_op(strlen(LONG_NAME), ==, 255); + tt_int_op(strlen(LONG_NAME), OP_EQ, 255); SET_CELL("\x00\xff" LONG_NAME "\x00\01\x00\x00"); - tt_int_op(rh.length, ==, 261); + tt_int_op(rh.length, OP_EQ, 261); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, 0); - tt_int_op(r, ==, 0); - tt_int_op(smartlist_len(addrs), ==, 1); + tt_int_op(errcode, OP_EQ, 0); + tt_int_op(r, OP_EQ, 0); + tt_int_op(smartlist_len(addrs), OP_EQ, 1); a = smartlist_get(addrs, 0); tt_assert(tor_addr_is_null(&a->addr)); - tt_str_op(a->hostname, ==, LONG_NAME); - tt_int_op(a->ttl, ==, 65536); + tt_str_op(a->hostname, OP_EQ, LONG_NAME); + tt_int_op(a->ttl, OP_EQ, 65536); CLEAR_ADDRS();

/* Cells with an error */ SET_CELL("\xf0\x2b" "I'm sorry, Dave. I'm afraid I can't do that" "\x00\x11\x22\x33"); - tt_int_op(rh.length, ==, 49); + tt_int_op(rh.length, OP_EQ, 49); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, RESOLVED_TYPE_ERROR_TRANSIENT); - tt_int_op(r, ==, 0); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(errcode, OP_EQ, RESOLVED_TYPE_ERROR_TRANSIENT); + tt_int_op(r, OP_EQ, 0); + tt_int_op(smartlist_len(addrs), OP_EQ, 0); CLEAR_ADDRS();

SET_CELL("\xf1\x40" "This hostname is too important for me to allow you to resolve it" "\x00\x00\x00\x00"); - tt_int_op(rh.length, ==, 70); + tt_int_op(rh.length, OP_EQ, 70); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, RESOLVED_TYPE_ERROR); - tt_int_op(r, ==, 0); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(errcode, OP_EQ, RESOLVED_TYPE_ERROR); + tt_int_op(r, OP_EQ, 0); + tt_int_op(smartlist_len(addrs), OP_EQ, 0); CLEAR_ADDRS();

/* Cell with an unrecognized type */ SET_CELL("\xee\x16" "fault in the AE35 unit" "\x09\x09\x01\x01"); - tt_int_op(rh.length, ==, 28); + tt_int_op(rh.length, OP_EQ, 28); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, 0); - tt_int_op(r, ==, 0); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(errcode, OP_EQ, 0); + tt_int_op(r, OP_EQ, 0); + tt_int_op(smartlist_len(addrs), OP_EQ, 0); CLEAR_ADDRS();

/* Cell with one of each */ @@ -1027,21 +1027,21 @@ test_cfmt_resolved_cells(void *arg) "\x00\00\x00\x00" ); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, 0); /* no error reported; we got answers */ - tt_int_op(r, ==, 0); - tt_int_op(smartlist_len(addrs), ==, 3); + tt_int_op(errcode, OP_EQ, 0); /* no error reported; we got answers */ + tt_int_op(r, OP_EQ, 0); + tt_int_op(smartlist_len(addrs), OP_EQ, 3); a = smartlist_get(addrs, 0); - tt_str_op(fmt_addr(&a->addr), ==, "2002:9090::f0f0:abcd"); - tt_ptr_op(a->hostname, ==, NULL); - tt_int_op(a->ttl, ==, 0x2000001); + tt_str_op(fmt_addr(&a->addr), OP_EQ, "2002:9090::f0f0:abcd"); + tt_ptr_op(a->hostname, OP_EQ, NULL); + tt_int_op(a->ttl, OP_EQ, 0x2000001); a = smartlist_get(addrs, 1); - tt_str_op(fmt_addr(&a->addr), ==, "127.0.2.10"); - tt_ptr_op(a->hostname, ==, NULL); - tt_int_op(a->ttl, ==, 256); + tt_str_op(fmt_addr(&a->addr), OP_EQ, "127.0.2.10"); + tt_ptr_op(a->hostname, OP_EQ, NULL); + tt_int_op(a->ttl, OP_EQ, 256); a = smartlist_get(addrs, 2); tt_assert(tor_addr_is_null(&a->addr)); - tt_str_op(a->hostname, ==, "motherbrain.zebes"); - tt_int_op(a->ttl, ==, 0); + tt_str_op(a->hostname, OP_EQ, "motherbrain.zebes"); + tt_int_op(a->ttl, OP_EQ, 0); CLEAR_ADDRS();

/* Cell with several of similar type */ @@ -1059,29 +1059,29 @@ test_cfmt_resolved_cells(void *arg) "\x00\x00\x00\x00\x00\xfa\xca\xde" "\x00\00\x00\x03"); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, 0); - tt_int_op(r, ==, 0); - tt_int_op(smartlist_len(addrs), ==, 5); + tt_int_op(errcode, OP_EQ, 0); + tt_int_op(r, OP_EQ, 0); + tt_int_op(smartlist_len(addrs), OP_EQ, 5); a = smartlist_get(addrs, 0); - tt_str_op(fmt_addr(&a->addr), ==, "127.0.2.10"); - tt_ptr_op(a->hostname, ==, NULL); - tt_int_op(a->ttl, ==, 256); + tt_str_op(fmt_addr(&a->addr), OP_EQ, "127.0.2.10"); + tt_ptr_op(a->hostname, OP_EQ, NULL); + tt_int_op(a->ttl, OP_EQ, 256); a = smartlist_get(addrs, 1); - tt_str_op(fmt_addr(&a->addr), ==, "8.8.8.8"); - tt_ptr_op(a->hostname, ==, NULL); - tt_int_op(a->ttl, ==, 261); + tt_str_op(fmt_addr(&a->addr), OP_EQ, "8.8.8.8"); + tt_ptr_op(a->hostname, OP_EQ, NULL); + tt_int_op(a->ttl, OP_EQ, 261); a = smartlist_get(addrs, 2); - tt_str_op(fmt_addr(&a->addr), ==, "127.176.2.176"); - tt_ptr_op(a->hostname, ==, NULL); - tt_int_op(a->ttl, ==, 131071); + tt_str_op(fmt_addr(&a->addr), OP_EQ, "127.176.2.176"); + tt_ptr_op(a->hostname, OP_EQ, NULL); + tt_int_op(a->ttl, OP_EQ, 131071); a = smartlist_get(addrs, 3); - tt_str_op(fmt_addr(&a->addr), ==, "2002:9000::cafe:f00d"); - tt_ptr_op(a->hostname, ==, NULL); - tt_int_op(a->ttl, ==, 1); + tt_str_op(fmt_addr(&a->addr), OP_EQ, "2002:9000::cafe:f00d"); + tt_ptr_op(a->hostname, OP_EQ, NULL); + tt_int_op(a->ttl, OP_EQ, 1); a = smartlist_get(addrs, 4); - tt_str_op(fmt_addr(&a->addr), ==, "2002:9001::fa:cade"); - tt_ptr_op(a->hostname, ==, NULL); - tt_int_op(a->ttl, ==, 3); + tt_str_op(fmt_addr(&a->addr), OP_EQ, "2002:9001::fa:cade"); + tt_ptr_op(a->hostname, OP_EQ, NULL); + tt_int_op(a->ttl, OP_EQ, 3); CLEAR_ADDRS();

/* Full cell */ @@ -1091,22 +1091,22 @@ test_cfmt_resolved_cells(void *arg) "g-case.to-avoid-off-by-one-errors.where-full-things-are-misreported-as" \ ".overflowing-by-one.z"

- tt_int_op(strlen(LONG_NAME2), ==, 231); + tt_int_op(strlen(LONG_NAME2), OP_EQ, 231); SET_CELL("\x00\xff" LONG_NAME "\x00\01\x00\x00" "\x00\xe7" LONG_NAME2 "\x00\01\x00\x00"); - tt_int_op(rh.length, ==, RELAY_PAYLOAD_SIZE); + tt_int_op(rh.length, OP_EQ, RELAY_PAYLOAD_SIZE); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, 0); - tt_int_op(r, ==, 0); - tt_int_op(smartlist_len(addrs), ==, 2); + tt_int_op(errcode, OP_EQ, 0); + tt_int_op(r, OP_EQ, 0); + tt_int_op(smartlist_len(addrs), OP_EQ, 2); a = smartlist_get(addrs, 0); - tt_str_op(a->hostname, ==, LONG_NAME); + tt_str_op(a->hostname, OP_EQ, LONG_NAME); a = smartlist_get(addrs, 1); - tt_str_op(a->hostname, ==, LONG_NAME2); + tt_str_op(a->hostname, OP_EQ, LONG_NAME2); CLEAR_ADDRS();

/* BAD CELLS */ @@ -1114,49 +1114,49 @@ test_cfmt_resolved_cells(void *arg) /* Invalid length on an IPv4 */ SET_CELL("\x04\x03zzz1234"); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, 0); - tt_int_op(r, ==, -1); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(errcode, OP_EQ, 0); + tt_int_op(r, OP_EQ, -1); + tt_int_op(smartlist_len(addrs), OP_EQ, 0); SET_CELL("\x04\x04" "\x7f\x00\x02\x0a" "\x00\00\x01\x00" "\x04\x05zzzzz1234"); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, 0); - tt_int_op(r, ==, -1); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(errcode, OP_EQ, 0); + tt_int_op(r, OP_EQ, -1); + tt_int_op(smartlist_len(addrs), OP_EQ, 0);

/* Invalid length on an IPv6 */ SET_CELL("\x06\x03zzz1234"); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, 0); - tt_int_op(r, ==, -1); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(errcode, OP_EQ, 0); + tt_int_op(r, OP_EQ, -1); + tt_int_op(smartlist_len(addrs), OP_EQ, 0); SET_CELL("\x04\x04" "\x7f\x00\x02\x0a" "\x00\00\x01\x00" "\x06\x17wwwwwwwwwwwwwwwww1234"); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, 0); - tt_int_op(r, ==, -1); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(errcode, OP_EQ, 0); + tt_int_op(r, OP_EQ, -1); + tt_int_op(smartlist_len(addrs), OP_EQ, 0); SET_CELL("\x04\x04" "\x7f\x00\x02\x0a" "\x00\00\x01\x00" "\x06\x10xxxx"); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, 0); - tt_int_op(r, ==, -1); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(errcode, OP_EQ, 0); + tt_int_op(r, OP_EQ, -1); + tt_int_op(smartlist_len(addrs), OP_EQ, 0);

/* Empty hostname */ SET_CELL("\x00\x00xxxx"); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, 0); - tt_int_op(r, ==, -1); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(errcode, OP_EQ, 0); + tt_int_op(r, OP_EQ, -1); + tt_int_op(smartlist_len(addrs), OP_EQ, 0);

/* rh.length out of range */ CLEAR_CELL(); rh.length = 499; r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(errcode, ==, 0); - tt_int_op(r, ==, -1); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(errcode, OP_EQ, 0); + tt_int_op(r, OP_EQ, -1); + tt_int_op(smartlist_len(addrs), OP_EQ, 0);

/* Item length extends beyond rh.length */ CLEAR_CELL(); @@ -1165,18 +1165,18 @@ test_cfmt_resolved_cells(void *arg) "\x00\01\x00\x00"); rh.length -= 1; r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(r, ==, -1); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(r, OP_EQ, -1); + tt_int_op(smartlist_len(addrs), OP_EQ, 0); rh.length -= 5; r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(r, ==, -1); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(r, OP_EQ, -1); + tt_int_op(smartlist_len(addrs), OP_EQ, 0);

SET_CELL("\x04\x04" "\x7f\x00\x02\x0a" "\x00\00\x01\x00"); rh.length -= 1; r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(r, ==, -1); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(r, OP_EQ, -1); + tt_int_op(smartlist_len(addrs), OP_EQ, 0);

SET_CELL("\xee\x10" "\x20\x02\x90\x01\x00\x00\x00\x00" @@ -1184,19 +1184,19 @@ test_cfmt_resolved_cells(void *arg) "\x00\00\x00\x03"); rh.length -= 1; r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(r, ==, -1); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(r, OP_EQ, -1); + tt_int_op(smartlist_len(addrs), OP_EQ, 0);

/* Truncated item after first character */ SET_CELL("\x04"); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(r, ==, -1); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(r, OP_EQ, -1); + tt_int_op(smartlist_len(addrs), OP_EQ, 0);

SET_CELL("\xee"); r = resolved_cell_parse(&cell, &rh, addrs, &errcode); - tt_int_op(r, ==, -1); - tt_int_op(smartlist_len(addrs), ==, 0); + tt_int_op(r, OP_EQ, -1); + tt_int_op(smartlist_len(addrs), OP_EQ, 0);

done: CLEAR_ADDRS(); @@ -1224,19 +1224,19 @@ test_cfmt_is_destroy(void *arg) cell_pack(&packed, &cell, 0); chan->wide_circ_ids = 0; tt_assert(! packed_cell_is_destroy(chan, &packed, &circid)); - tt_int_op(circid, ==, 0); + tt_int_op(circid, OP_EQ, 0);

cell_pack(&packed, &cell, 1); chan->wide_circ_ids = 1; tt_assert(! packed_cell_is_destroy(chan, &packed, &circid)); - tt_int_op(circid, ==, 0); + tt_int_op(circid, OP_EQ, 0);

cell.command = CELL_DESTROY;

cell_pack(&packed, &cell, 0); chan->wide_circ_ids = 0; tt_assert(packed_cell_is_destroy(chan, &packed, &circid)); - tt_int_op(circid, ==, 3003); + tt_int_op(circid, OP_EQ, 3003);

circid = 0; cell_pack(&packed, &cell, 1); diff --git a/src/test/test_cell_queue.c b/src/test/test_cell_queue.c index e43c100..e2fc95c 100644 --- a/src/test/test_cell_queue.c +++ b/src/test/test_cell_queue.c @@ -21,7 +21,7 @@ test_cq_manip(void *arg) #endif /* ENABLE_MEMPOOLS */

cell_queue_init(&cq); - tt_int_op(cq.n, ==, 0); + tt_int_op(cq.n, OP_EQ, 0);

pc1 = packed_cell_new(); pc2 = packed_cell_new(); @@ -29,26 +29,26 @@ test_cq_manip(void *arg) pc4 = packed_cell_new(); tt_assert(pc1 && pc2 && pc3 && pc4);

- tt_ptr_op(NULL, ==, cell_queue_pop(&cq)); + tt_ptr_op(NULL, OP_EQ, cell_queue_pop(&cq));

/* Add and remove a singleton. */ cell_queue_append(&cq, pc1); - tt_int_op(cq.n, ==, 1); - tt_ptr_op(pc1, ==, cell_queue_pop(&cq)); - tt_int_op(cq.n, ==, 0); + tt_int_op(cq.n, OP_EQ, 1); + tt_ptr_op(pc1, OP_EQ, cell_queue_pop(&cq)); + tt_int_op(cq.n, OP_EQ, 0);

/* Add and remove four items */ cell_queue_append(&cq, pc4); cell_queue_append(&cq, pc3); cell_queue_append(&cq, pc2); cell_queue_append(&cq, pc1); - tt_int_op(cq.n, ==, 4); - tt_ptr_op(pc4, ==, cell_queue_pop(&cq)); - tt_ptr_op(pc3, ==, cell_queue_pop(&cq)); - tt_ptr_op(pc2, ==, cell_queue_pop(&cq)); - tt_ptr_op(pc1, ==, cell_queue_pop(&cq)); - tt_int_op(cq.n, ==, 0); - tt_ptr_op(NULL, ==, cell_queue_pop(&cq)); + tt_int_op(cq.n, OP_EQ, 4); + tt_ptr_op(pc4, OP_EQ, cell_queue_pop(&cq)); + tt_ptr_op(pc3, OP_EQ, cell_queue_pop(&cq)); + tt_ptr_op(pc2, OP_EQ, cell_queue_pop(&cq)); + tt_ptr_op(pc1, OP_EQ, cell_queue_pop(&cq)); + tt_int_op(cq.n, OP_EQ, 0); + tt_ptr_op(NULL, OP_EQ, cell_queue_pop(&cq));

/* Try a packed copy (wide, then narrow, which is a bit of a cheat, since a * real cell queue has only one type.) */ @@ -64,32 +64,32 @@ test_cq_manip(void *arg) cell.circ_id = 0x2013; cell_queue_append_packed_copy(NULL /*circ*/, &cq, 0 /*exitward*/, &cell, 0 /*wide*/, 0 /*stats*/); - tt_int_op(cq.n, ==, 2); + tt_int_op(cq.n, OP_EQ, 2);

pc_tmp = cell_queue_pop(&cq); - tt_int_op(cq.n, ==, 1); - tt_ptr_op(pc_tmp, !=, NULL); - tt_mem_op(pc_tmp->body, ==, "\x12\x34\x56\x78\x0a", 5); - tt_mem_op(pc_tmp->body+5, ==, cell.payload, sizeof(cell.payload)); + tt_int_op(cq.n, OP_EQ, 1); + tt_ptr_op(pc_tmp, OP_NE, NULL); + tt_mem_op(pc_tmp->body, OP_EQ, "\x12\x34\x56\x78\x0a", 5); + tt_mem_op(pc_tmp->body+5, OP_EQ, cell.payload, sizeof(cell.payload)); packed_cell_free(pc_tmp);

pc_tmp = cell_queue_pop(&cq); - tt_int_op(cq.n, ==, 0); - tt_ptr_op(pc_tmp, !=, NULL); - tt_mem_op(pc_tmp->body, ==, "\x20\x13\x0a", 3); - tt_mem_op(pc_tmp->body+3, ==, cell.payload, sizeof(cell.payload)); + tt_int_op(cq.n, OP_EQ, 0); + tt_ptr_op(pc_tmp, OP_NE, NULL); + tt_mem_op(pc_tmp->body, OP_EQ, "\x20\x13\x0a", 3); + tt_mem_op(pc_tmp->body+3, OP_EQ, cell.payload, sizeof(cell.payload)); packed_cell_free(pc_tmp); pc_tmp = NULL;

- tt_ptr_op(NULL, ==, cell_queue_pop(&cq)); + tt_ptr_op(NULL, OP_EQ, cell_queue_pop(&cq));

/* Now make sure cell_queue_clear works. */ cell_queue_append(&cq, pc2); cell_queue_append(&cq, pc1); - tt_int_op(cq.n, ==, 2); + tt_int_op(cq.n, OP_EQ, 2); cell_queue_clear(&cq); pc2 = pc1 = NULL; /* prevent double-free */ - tt_int_op(cq.n, ==, 0); + tt_int_op(cq.n, OP_EQ, 0);

done: packed_cell_free(pc1); @@ -129,17 +129,17 @@ test_circuit_n_cells(void *arg) origin_c = origin_circuit_new(); origin_c->base_.purpose = CIRCUIT_PURPOSE_C_GENERAL;

- tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(or_c)), ==, 0); + tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(or_c)), OP_EQ, 0); cell_queue_append(&or_c->p_chan_cells, pc1); - tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(or_c)), ==, 1); + tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(or_c)), OP_EQ, 1); cell_queue_append(&or_c->base_.n_chan_cells, pc2); cell_queue_append(&or_c->base_.n_chan_cells, pc3); - tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(or_c)), ==, 3); + tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(or_c)), OP_EQ, 3);

- tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(origin_c)), ==, 0); + tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(origin_c)), OP_EQ, 0); cell_queue_append(&origin_c->base_.n_chan_cells, pc4); cell_queue_append(&origin_c->base_.n_chan_cells, pc5); - tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(origin_c)), ==, 2); + tt_int_op(n_cells_in_circ_queues(TO_CIRCUIT(origin_c)), OP_EQ, 2);

done: circuit_free(TO_CIRCUIT(or_c)); diff --git a/src/test/test_checkdir.c b/src/test/test_checkdir.c index 5135816..6c52065 100644 --- a/src/test/test_checkdir.c +++ b/src/test/test_checkdir.c @@ -31,41 +31,41 @@ test_checkdir_perms(void *testdata) /* setup data directory before tests. */ tor_free(options->DataDirectory); options->DataDirectory = tor_strdup(get_fname(subdir)); - tt_int_op(mkdir(options->DataDirectory, 0750), ==, 0); + tt_int_op(mkdir(options->DataDirectory, 0750), OP_EQ, 0);

/* test: create new dir, no flags. */ testdir = get_datadir_fname("checkdir_new_none"); cpd_chkopts = CPD_CREATE; unix_verify_optsmask = 0077; - tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL)); - tt_int_op(0, ==, stat(testdir, &st)); - tt_int_op_nowin(0, ==, (st.st_mode & unix_verify_optsmask)); + tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL)); + tt_int_op(0, OP_EQ, stat(testdir, &st)); + tt_int_op_nowin(0, OP_EQ, (st.st_mode & unix_verify_optsmask)); tor_free(testdir);

/* test: create new dir, CPD_GROUP_OK option set. */ testdir = get_datadir_fname("checkdir_new_groupok"); cpd_chkopts = CPD_CREATE|CPD_GROUP_OK; unix_verify_optsmask = 0077; - tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL)); - tt_int_op(0, ==, stat(testdir, &st)); - tt_int_op_nowin(0, ==, (st.st_mode & unix_verify_optsmask)); + tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL)); + tt_int_op(0, OP_EQ, stat(testdir, &st)); + tt_int_op_nowin(0, OP_EQ, (st.st_mode & unix_verify_optsmask)); tor_free(testdir);

/* test: should get an error on existing dir with wrong perms */ testdir = get_datadir_fname("checkdir_new_groupok_err"); - tt_int_op(0, ==, mkdir(testdir, 027)); + tt_int_op(0, OP_EQ, mkdir(testdir, 027)); cpd_chkopts = CPD_CHECK_MODE_ONLY|CPD_CREATE|CPD_GROUP_OK; - tt_int_op_nowin(-1, ==, check_private_dir(testdir, cpd_chkopts, NULL)); + tt_int_op_nowin(-1, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL)); tor_free(testdir);

/* test: create new dir, CPD_GROUP_READ option set. */ testdir = get_datadir_fname("checkdir_new_groupread"); cpd_chkopts = CPD_CREATE|CPD_GROUP_READ; unix_verify_optsmask = 0027; - tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL)); - tt_int_op(0, ==, stat(testdir, &st)); - tt_int_op_nowin(0, ==, (st.st_mode & unix_verify_optsmask)); + tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL)); + tt_int_op(0, OP_EQ, stat(testdir, &st)); + tt_int_op_nowin(0, OP_EQ, (st.st_mode & unix_verify_optsmask)); tor_free(testdir);

/* test: check existing dir created with defaults, @@ -75,10 +75,10 @@ test_checkdir_perms(void *testdata) unix_create_opts = 0700; (void)unix_create_opts; unix_verify_optsmask = 0077; - tt_int_op(0, ==, mkdir(testdir, unix_create_opts)); - tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL)); - tt_int_op(0, ==, stat(testdir, &st)); - tt_int_op_nowin(0, ==, (st.st_mode & unix_verify_optsmask)); + tt_int_op(0, OP_EQ, mkdir(testdir, unix_create_opts)); + tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL)); + tt_int_op(0, OP_EQ, stat(testdir, &st)); + tt_int_op_nowin(0, OP_EQ, (st.st_mode & unix_verify_optsmask)); tor_free(testdir);

/* test: check existing dir created with defaults, @@ -86,11 +86,11 @@ test_checkdir_perms(void *testdata) testdir = get_datadir_fname("checkdir_exists_groupok"); cpd_chkopts = CPD_CREATE; unix_verify_optsmask = 0077; - tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL)); + tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL)); cpd_chkopts = CPD_GROUP_OK; - tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL)); - tt_int_op(0, ==, stat(testdir, &st)); - tt_int_op_nowin(0, ==, (st.st_mode & unix_verify_optsmask)); + tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL)); + tt_int_op(0, OP_EQ, stat(testdir, &st)); + tt_int_op_nowin(0, OP_EQ, (st.st_mode & unix_verify_optsmask)); tor_free(testdir);

/* test: check existing dir created with defaults, @@ -98,11 +98,11 @@ test_checkdir_perms(void *testdata) testdir = get_datadir_fname("checkdir_exists_groupread"); cpd_chkopts = CPD_CREATE; unix_verify_optsmask = 0027; - tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL)); + tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL)); cpd_chkopts = CPD_GROUP_READ; - tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL)); - tt_int_op(0, ==, stat(testdir, &st)); - tt_int_op_nowin(0, ==, (st.st_mode & unix_verify_optsmask)); + tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL)); + tt_int_op(0, OP_EQ, stat(testdir, &st)); + tt_int_op_nowin(0, OP_EQ, (st.st_mode & unix_verify_optsmask)); tor_free(testdir);

/* test: check existing dir created with CPD_GROUP_READ, @@ -110,11 +110,11 @@ test_checkdir_perms(void *testdata) testdir = get_datadir_fname("checkdir_existsread_groupok"); cpd_chkopts = CPD_CREATE|CPD_GROUP_READ; unix_verify_optsmask = 0027; - tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL)); + tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL)); cpd_chkopts = CPD_GROUP_OK; - tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL)); - tt_int_op(0, ==, stat(testdir, &st)); - tt_int_op_nowin(0, ==, (st.st_mode & unix_verify_optsmask)); + tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL)); + tt_int_op(0, OP_EQ, stat(testdir, &st)); + tt_int_op_nowin(0, OP_EQ, (st.st_mode & unix_verify_optsmask)); tor_free(testdir);

/* test: check existing dir created with CPD_GROUP_READ, @@ -122,9 +122,9 @@ test_checkdir_perms(void *testdata) testdir = get_datadir_fname("checkdir_existsread_groupread"); cpd_chkopts = CPD_CREATE|CPD_GROUP_READ; unix_verify_optsmask = 0027; - tt_int_op(0, ==, check_private_dir(testdir, cpd_chkopts, NULL)); - tt_int_op(0, ==, stat(testdir, &st)); - tt_int_op_nowin(0, ==, (st.st_mode & unix_verify_optsmask)); + tt_int_op(0, OP_EQ, check_private_dir(testdir, cpd_chkopts, NULL)); + tt_int_op(0, OP_EQ, stat(testdir, &st)); + tt_int_op_nowin(0, OP_EQ, (st.st_mode & unix_verify_optsmask));

done: tor_free(testdir); diff --git a/src/test/test_circuitlist.c b/src/test/test_circuitlist.c index fb5488b..181aec2 100644 --- a/src/test/test_circuitlist.c +++ b/src/test/test_circuitlist.c @@ -50,17 +50,17 @@ circuitmux_detach_mock(circuitmux_t *cmux, circuit_t *circ) }

#define GOT_CMUX_ATTACH(mux_, circ_, dir_) do { \ - tt_int_op(cam.ncalls, ==, 1); \ - tt_ptr_op(cam.cmux, ==, (mux_)); \ - tt_ptr_op(cam.circ, ==, (circ_)); \ - tt_int_op(cam.dir, ==, (dir_)); \ + tt_int_op(cam.ncalls, OP_EQ, 1); \ + tt_ptr_op(cam.cmux, OP_EQ, (mux_)); \ + tt_ptr_op(cam.circ, OP_EQ, (circ_)); \ + tt_int_op(cam.dir, OP_EQ, (dir_)); \ memset(&cam, 0, sizeof(cam)); \ } while (0)

#define GOT_CMUX_DETACH(mux_, circ_) do { \ - tt_int_op(cdm.ncalls, ==, 1); \ - tt_ptr_op(cdm.cmux, ==, (mux_)); \ - tt_ptr_op(cdm.circ, ==, (circ_)); \ + tt_int_op(cdm.ncalls, OP_EQ, 1); \ + tt_ptr_op(cdm.cmux, OP_EQ, (mux_)); \ + tt_ptr_op(cdm.circ, OP_EQ, (circ_)); \ memset(&cdm, 0, sizeof(cdm)); \ } while (0)

@@ -90,14 +90,14 @@ test_clist_maps(void *arg) or_c1 = or_circuit_new(100, ch2); tt_assert(or_c1); GOT_CMUX_ATTACH(ch2->cmux, or_c1, CELL_DIRECTION_IN); - tt_int_op(or_c1->p_circ_id, ==, 100); - tt_ptr_op(or_c1->p_chan, ==, ch2); + tt_int_op(or_c1->p_circ_id, OP_EQ, 100); + tt_ptr_op(or_c1->p_chan, OP_EQ, ch2);

or_c2 = or_circuit_new(100, ch1); tt_assert(or_c2); GOT_CMUX_ATTACH(ch1->cmux, or_c2, CELL_DIRECTION_IN); - tt_int_op(or_c2->p_circ_id, ==, 100); - tt_ptr_op(or_c2->p_chan, ==, ch1); + tt_int_op(or_c2->p_circ_id, OP_EQ, 100); + tt_ptr_op(or_c2->p_chan, OP_EQ, ch1);

circuit_set_n_circid_chan(TO_CIRCUIT(or_c1), 200, ch1); GOT_CMUX_ATTACH(ch1->cmux, or_c1, CELL_DIRECTION_OUT); @@ -105,11 +105,11 @@ test_clist_maps(void *arg) circuit_set_n_circid_chan(TO_CIRCUIT(or_c2), 200, ch2); GOT_CMUX_ATTACH(ch2->cmux, or_c2, CELL_DIRECTION_OUT);

- tt_ptr_op(circuit_get_by_circid_channel(200, ch1), ==, TO_CIRCUIT(or_c1)); - tt_ptr_op(circuit_get_by_circid_channel(200, ch2), ==, TO_CIRCUIT(or_c2)); - tt_ptr_op(circuit_get_by_circid_channel(100, ch2), ==, TO_CIRCUIT(or_c1)); + tt_ptr_op(circuit_get_by_circid_channel(200, ch1), OP_EQ, TO_CIRCUIT(or_c1)); + tt_ptr_op(circuit_get_by_circid_channel(200, ch2), OP_EQ, TO_CIRCUIT(or_c2)); + tt_ptr_op(circuit_get_by_circid_channel(100, ch2), OP_EQ, TO_CIRCUIT(or_c1)); /* Try the same thing again, to test the "fast" path. */ - tt_ptr_op(circuit_get_by_circid_channel(100, ch2), ==, TO_CIRCUIT(or_c1)); + tt_ptr_op(circuit_get_by_circid_channel(100, ch2), OP_EQ, TO_CIRCUIT(or_c1)); tt_assert(circuit_id_in_use_on_channel(100, ch2)); tt_assert(! circuit_id_in_use_on_channel(101, ch2));

@@ -117,9 +117,9 @@ test_clist_maps(void *arg) circuit_set_p_circid_chan(or_c1, 500, ch3); GOT_CMUX_DETACH(ch2->cmux, TO_CIRCUIT(or_c1)); GOT_CMUX_ATTACH(ch3->cmux, TO_CIRCUIT(or_c1), CELL_DIRECTION_IN); - tt_ptr_op(circuit_get_by_circid_channel(100, ch2), ==, NULL); + tt_ptr_op(circuit_get_by_circid_channel(100, ch2), OP_EQ, NULL); tt_assert(! circuit_id_in_use_on_channel(100, ch2)); - tt_ptr_op(circuit_get_by_circid_channel(500, ch3), ==, TO_CIRCUIT(or_c1)); + tt_ptr_op(circuit_get_by_circid_channel(500, ch3), OP_EQ, TO_CIRCUIT(or_c1));

/* Now let's see about destroy handling. */ tt_assert(! circuit_id_in_use_on_channel(205, ch2)); @@ -132,26 +132,26 @@ test_clist_maps(void *arg) tt_assert(circuit_id_in_use_on_channel(100, ch1));

tt_assert(TO_CIRCUIT(or_c2)->n_delete_pending != 0); - tt_ptr_op(circuit_get_by_circid_channel(200, ch2), ==, TO_CIRCUIT(or_c2)); - tt_ptr_op(circuit_get_by_circid_channel(100, ch1), ==, TO_CIRCUIT(or_c2)); + tt_ptr_op(circuit_get_by_circid_channel(200, ch2), OP_EQ, TO_CIRCUIT(or_c2)); + tt_ptr_op(circuit_get_by_circid_channel(100, ch1), OP_EQ, TO_CIRCUIT(or_c2));

/* Okay, now free ch2 and make sure that the circuit ID is STILL not * usable, because we haven't declared the destroy to be nonpending */ - tt_int_op(cdm.ncalls, ==, 0); + tt_int_op(cdm.ncalls, OP_EQ, 0); circuit_free(TO_CIRCUIT(or_c2)); or_c2 = NULL; /* prevent free */ - tt_int_op(cdm.ncalls, ==, 2); + tt_int_op(cdm.ncalls, OP_EQ, 2); memset(&cdm, 0, sizeof(cdm)); tt_assert(circuit_id_in_use_on_channel(200, ch2)); tt_assert(circuit_id_in_use_on_channel(100, ch1)); - tt_ptr_op(circuit_get_by_circid_channel(200, ch2), ==, NULL); - tt_ptr_op(circuit_get_by_circid_channel(100, ch1), ==, NULL); + tt_ptr_op(circuit_get_by_circid_channel(200, ch2), OP_EQ, NULL); + tt_ptr_op(circuit_get_by_circid_channel(100, ch1), OP_EQ, NULL);

/* Now say that the destroy is nonpending */ channel_note_destroy_not_pending(ch2, 200); - tt_ptr_op(circuit_get_by_circid_channel(200, ch2), ==, NULL); + tt_ptr_op(circuit_get_by_circid_channel(200, ch2), OP_EQ, NULL); channel_note_destroy_not_pending(ch1, 100); - tt_ptr_op(circuit_get_by_circid_channel(100, ch1), ==, NULL); + tt_ptr_op(circuit_get_by_circid_channel(100, ch1), OP_EQ, NULL); tt_assert(! circuit_id_in_use_on_channel(200, ch2)); tt_assert(! circuit_id_in_use_on_channel(100, ch1));

@@ -190,73 +190,73 @@ test_rend_token_maps(void *arg) c4 = or_circuit_new(0, NULL);

/* Make sure we really filled up the tok* variables */ - tt_int_op(tok1[REND_TOKEN_LEN-1], ==, 'y'); - tt_int_op(tok2[REND_TOKEN_LEN-1], ==, ' '); - tt_int_op(tok3[REND_TOKEN_LEN-1], ==, '.'); + tt_int_op(tok1[REND_TOKEN_LEN-1], OP_EQ, 'y'); + tt_int_op(tok2[REND_TOKEN_LEN-1], OP_EQ, ' '); + tt_int_op(tok3[REND_TOKEN_LEN-1], OP_EQ, '.');

/* No maps; nothing there. */ - tt_ptr_op(NULL, ==, circuit_get_rendezvous(tok1)); - tt_ptr_op(NULL, ==, circuit_get_intro_point(tok1)); + tt_ptr_op(NULL, OP_EQ, circuit_get_rendezvous(tok1)); + tt_ptr_op(NULL, OP_EQ, circuit_get_intro_point(tok1));

circuit_set_rendezvous_cookie(c1, tok1); circuit_set_intro_point_digest(c2, tok2);

- tt_ptr_op(NULL, ==, circuit_get_rendezvous(tok3)); - tt_ptr_op(NULL, ==, circuit_get_intro_point(tok3)); - tt_ptr_op(NULL, ==, circuit_get_rendezvous(tok2)); - tt_ptr_op(NULL, ==, circuit_get_intro_point(tok1)); + tt_ptr_op(NULL, OP_EQ, circuit_get_rendezvous(tok3)); + tt_ptr_op(NULL, OP_EQ, circuit_get_intro_point(tok3)); + tt_ptr_op(NULL, OP_EQ, circuit_get_rendezvous(tok2)); + tt_ptr_op(NULL, OP_EQ, circuit_get_intro_point(tok1));

/* Without purpose set, we don't get the circuits */ - tt_ptr_op(NULL, ==, circuit_get_rendezvous(tok1)); - tt_ptr_op(NULL, ==, circuit_get_intro_point(tok2)); + tt_ptr_op(NULL, OP_EQ, circuit_get_rendezvous(tok1)); + tt_ptr_op(NULL, OP_EQ, circuit_get_intro_point(tok2));

c1->base_.purpose = CIRCUIT_PURPOSE_REND_POINT_WAITING; c2->base_.purpose = CIRCUIT_PURPOSE_INTRO_POINT;

/* Okay, make sure they show up now. */ - tt_ptr_op(c1, ==, circuit_get_rendezvous(tok1)); - tt_ptr_op(c2, ==, circuit_get_intro_point(tok2)); + tt_ptr_op(c1, OP_EQ, circuit_get_rendezvous(tok1)); + tt_ptr_op(c2, OP_EQ, circuit_get_intro_point(tok2));

/* Two items at the same place with the same token. */ c3->base_.purpose = CIRCUIT_PURPOSE_REND_POINT_WAITING; circuit_set_rendezvous_cookie(c3, tok2); - tt_ptr_op(c2, ==, circuit_get_intro_point(tok2)); - tt_ptr_op(c3, ==, circuit_get_rendezvous(tok2)); + tt_ptr_op(c2, OP_EQ, circuit_get_intro_point(tok2)); + tt_ptr_op(c3, OP_EQ, circuit_get_rendezvous(tok2));

/* Marking a circuit makes it not get returned any more */ circuit_mark_for_close(TO_CIRCUIT(c1), END_CIRC_REASON_FINISHED); - tt_ptr_op(NULL, ==, circuit_get_rendezvous(tok1)); + tt_ptr_op(NULL, OP_EQ, circuit_get_rendezvous(tok1)); circuit_free(TO_CIRCUIT(c1)); c1 = NULL;

/* Freeing a circuit makes it not get returned any more. */ circuit_free(TO_CIRCUIT(c2)); c2 = NULL; - tt_ptr_op(NULL, ==, circuit_get_intro_point(tok2)); + tt_ptr_op(NULL, OP_EQ, circuit_get_intro_point(tok2));

/* c3 -- are you still there? */ - tt_ptr_op(c3, ==, circuit_get_rendezvous(tok2)); + tt_ptr_op(c3, OP_EQ, circuit_get_rendezvous(tok2)); /* Change its cookie. This never happens in Tor per se, but hey. */ c3->base_.purpose = CIRCUIT_PURPOSE_INTRO_POINT; circuit_set_intro_point_digest(c3, tok3);

- tt_ptr_op(NULL, ==, circuit_get_rendezvous(tok2)); - tt_ptr_op(c3, ==, circuit_get_intro_point(tok3)); + tt_ptr_op(NULL, OP_EQ, circuit_get_rendezvous(tok2)); + tt_ptr_op(c3, OP_EQ, circuit_get_intro_point(tok3));

/* Now replace c3 with c4. */ c4->base_.purpose = CIRCUIT_PURPOSE_INTRO_POINT; circuit_set_intro_point_digest(c4, tok3);

- tt_ptr_op(c4, ==, circuit_get_intro_point(tok3)); + tt_ptr_op(c4, OP_EQ, circuit_get_intro_point(tok3));

- tt_ptr_op(c3->rendinfo, ==, NULL); - tt_ptr_op(c4->rendinfo, !=, NULL); - tt_mem_op(c4->rendinfo, ==, tok3, REND_TOKEN_LEN); + tt_ptr_op(c3->rendinfo, OP_EQ, NULL); + tt_ptr_op(c4->rendinfo, OP_NE, NULL); + tt_mem_op(c4->rendinfo, OP_EQ, tok3, REND_TOKEN_LEN);

/* Now clear c4's cookie. */ circuit_set_intro_point_digest(c4, NULL); - tt_ptr_op(c4->rendinfo, ==, NULL); - tt_ptr_op(NULL, ==, circuit_get_intro_point(tok3)); + tt_ptr_op(c4->rendinfo, OP_EQ, NULL); + tt_ptr_op(NULL, OP_EQ, circuit_get_intro_point(tok3));

done: if (c1) @@ -283,32 +283,32 @@ test_pick_circid(void *arg) chan2->wide_circ_ids = 1;

chan1->circ_id_type = CIRC_ID_TYPE_NEITHER; - tt_int_op(0, ==, get_unique_circ_id_by_chan(chan1)); + tt_int_op(0, OP_EQ, get_unique_circ_id_by_chan(chan1));

/* Basic tests, with no collisions */ chan1->circ_id_type = CIRC_ID_TYPE_LOWER; for (i = 0; i < 50; ++i) { circid = get_unique_circ_id_by_chan(chan1); - tt_uint_op(0, <, circid); - tt_uint_op(circid, <, (1<<15)); + tt_uint_op(0, OP_LT, circid); + tt_uint_op(circid, OP_LT, (1<<15)); } chan1->circ_id_type = CIRC_ID_TYPE_HIGHER; for (i = 0; i < 50; ++i) { circid = get_unique_circ_id_by_chan(chan1); - tt_uint_op((1<<15), <, circid); - tt_uint_op(circid, <, (1<<16)); + tt_uint_op((1<<15), OP_LT, circid); + tt_uint_op(circid, OP_LT, (1<<16)); }

chan2->circ_id_type = CIRC_ID_TYPE_LOWER; for (i = 0; i < 50; ++i) { circid = get_unique_circ_id_by_chan(chan2); - tt_uint_op(0, <, circid); - tt_uint_op(circid, <, (1u<<31)); + tt_uint_op(0, OP_LT, circid); + tt_uint_op(circid, OP_LT, (1u<<31)); } chan2->circ_id_type = CIRC_ID_TYPE_HIGHER; for (i = 0; i < 50; ++i) { circid = get_unique_circ_id_by_chan(chan2); - tt_uint_op((1u<<31), <, circid); + tt_uint_op((1u<<31), OP_LT, circid); }

/* Now make sure that we can behave well when we are full up on circuits */ @@ -319,20 +319,20 @@ test_pick_circid(void *arg) for (i = 0; i < (1<<15); ++i) { circid = get_unique_circ_id_by_chan(chan1); if (circid == 0) { - tt_int_op(i, >, (1<<14)); + tt_int_op(i, OP_GT, (1<<14)); break; } - tt_uint_op(circid, <, (1<<15)); + tt_uint_op(circid, OP_LT, (1<<15)); tt_assert(! bitarray_is_set(ba, circid)); bitarray_set(ba, circid); channel_mark_circid_unusable(chan1, circid); } - tt_int_op(i, <, (1<<15)); + tt_int_op(i, OP_LT, (1<<15)); /* Make sure that being full on chan1 does not interfere with chan2 */ for (i = 0; i < 100; ++i) { circid = get_unique_circ_id_by_chan(chan2); - tt_uint_op(circid, >, 0); - tt_uint_op(circid, <, (1<<15)); + tt_uint_op(circid, OP_GT, 0); + tt_uint_op(circid, OP_LT, (1<<15)); channel_mark_circid_unusable(chan2, circid); }

diff --git a/src/test/test_circuitmux.c b/src/test/test_circuitmux.c index 446fc88..b8590d6 100644 --- a/src/test/test_circuitmux.c +++ b/src/test/test_circuitmux.c @@ -55,21 +55,21 @@ test_cmux_destroy_cell_queue(void *arg) circuitmux_append_destroy_cell(ch, cmux, 190, 6); circuitmux_append_destroy_cell(ch, cmux, 30, 1);

- tt_int_op(circuitmux_num_cells(cmux), ==, 3); + tt_int_op(circuitmux_num_cells(cmux), OP_EQ, 3);

circ = circuitmux_get_first_active_circuit(cmux, &cq); tt_assert(!circ); tt_assert(cq);

- tt_int_op(cq->n, ==, 3); + tt_int_op(cq->n, OP_EQ, 3);

pc = cell_queue_pop(cq); tt_assert(pc); - tt_mem_op(pc->body, ==, "\x00\x00\x00\x64\x04\x0a\x00\x00\x00", 9); + tt_mem_op(pc->body, OP_EQ, "\x00\x00\x00\x64\x04\x0a\x00\x00\x00", 9); packed_cell_free(pc); pc = NULL;

- tt_int_op(circuitmux_num_cells(cmux), ==, 2); + tt_int_op(circuitmux_num_cells(cmux), OP_EQ, 2);

done: circuitmux_free(cmux); diff --git a/src/test/test_config.c b/src/test/test_config.c index 71c338e..1560c5c 100644 --- a/src/test/test_config.c +++ b/src/test/test_config.c @@ -65,22 +65,22 @@ test_config_addressmap(void *arg) /* MapAddress .google.com .torserver.exit */ strlcpy(address, "reader.google.com", sizeof(address)); tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL)); - tt_str_op(address,==, "reader.torserver.exit"); + tt_str_op(address,OP_EQ, "reader.torserver.exit");

/* MapAddress *.yahoo.com *.google.com.torserver.exit */ strlcpy(address, "reader.yahoo.com", sizeof(address)); tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL)); - tt_str_op(address,==, "reader.google.com.torserver.exit"); + tt_str_op(address,OP_EQ, "reader.google.com.torserver.exit");

/*MapAddress *.cnn.com www.cnn.com */ strlcpy(address, "cnn.com", sizeof(address)); tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL)); - tt_str_op(address,==, "www.cnn.com"); + tt_str_op(address,OP_EQ, "www.cnn.com");

/* MapAddress .cn.com www.cnn.com */ strlcpy(address, "www.cn.com", sizeof(address)); tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL)); - tt_str_op(address,==, "www.cnn.com"); + tt_str_op(address,OP_EQ, "www.cnn.com");

/* MapAddress ex.com www.cnn.com - no match */ strlcpy(address, "www.ex.com", sizeof(address)); @@ -93,19 +93,19 @@ test_config_addressmap(void *arg) /* Where mapping for FQDN match on FQDN */ strlcpy(address, "www.google.com", sizeof(address)); tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL)); - tt_str_op(address,==, "3.3.3.3"); + tt_str_op(address,OP_EQ, "3.3.3.3");

strlcpy(address, "www.torproject.org", sizeof(address)); tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL)); - tt_str_op(address,==, "1.1.1.1"); + tt_str_op(address,OP_EQ, "1.1.1.1");

strlcpy(address, "other.torproject.org", sizeof(address)); tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL)); - tt_str_op(address,==, "this.torproject.org.otherserver.exit"); + tt_str_op(address,OP_EQ, "this.torproject.org.otherserver.exit");

strlcpy(address, "test.torproject.org", sizeof(address)); tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL)); - tt_str_op(address,==, "2.2.2.2"); + tt_str_op(address,OP_EQ, "2.2.2.2");

/* Test a chain of address mappings and the order in which they were added: "MapAddress www.example.org 4.4.4.4" @@ -114,12 +114,12 @@ test_config_addressmap(void *arg) */ strlcpy(address, "www.example.org", sizeof(address)); tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL)); - tt_str_op(address,==, "5.5.5.5"); + tt_str_op(address,OP_EQ, "5.5.5.5");

/* Test infinite address mapping results in no change */ strlcpy(address, "www.infiniteloop.org", sizeof(address)); tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL)); - tt_str_op(address,==, "www.infiniteloop.org"); + tt_str_op(address,OP_EQ, "www.infiniteloop.org");

/* Test we don't find false positives */ strlcpy(address, "www.example.com", sizeof(address)); @@ -137,23 +137,23 @@ test_config_addressmap(void *arg)

strlcpy(address, "www.abc.com", sizeof(address)); tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL)); - tt_str_op(address,==, "www.abc.torserver.exit"); + tt_str_op(address,OP_EQ, "www.abc.torserver.exit");

strlcpy(address, "www.def.com", sizeof(address)); tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL)); - tt_str_op(address,==, "www.def.torserver.exit"); + tt_str_op(address,OP_EQ, "www.def.torserver.exit");

strlcpy(address, "www.torproject.org", sizeof(address)); tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL)); - tt_str_op(address,==, "1.1.1.1"); + tt_str_op(address,OP_EQ, "1.1.1.1");

strlcpy(address, "test.torproject.org", sizeof(address)); tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL)); - tt_str_op(address,==, "1.1.1.1"); + tt_str_op(address,OP_EQ, "1.1.1.1");

strlcpy(address, "torproject.net", sizeof(address)); tt_assert(addressmap_rewrite(address, sizeof(address), &expires, NULL)); - tt_str_op(address,==, "2.2.2.2"); + tt_str_op(address,OP_EQ, "2.2.2.2");

/* We don't support '*' as a mapping directive */ config_free_lines(get_options_mutable()->AddressMap); @@ -213,9 +213,9 @@ test_config_check_or_create_data_subdir(void *arg) subpath = get_datadir_fname(subdir);

#if defined (_WIN32) - tt_int_op(mkdir(options->DataDirectory), ==, 0); + tt_int_op(mkdir(options->DataDirectory), OP_EQ, 0); #else - tt_int_op(mkdir(options->DataDirectory, 0700), ==, 0); + tt_int_op(mkdir(options->DataDirectory, 0700), OP_EQ, 0); #endif

r = stat(subpath, &st); @@ -287,9 +287,9 @@ test_config_write_to_data_subdir(void *arg) filepath = get_datadir_fname2(subdir, fname);

#if defined (_WIN32) - tt_int_op(mkdir(options->DataDirectory), ==, 0); + tt_int_op(mkdir(options->DataDirectory), OP_EQ, 0); #else - tt_int_op(mkdir(options->DataDirectory, 0700), ==, 0); + tt_int_op(mkdir(options->DataDirectory, 0700), OP_EQ, 0); #endif

// Write attempt shoudl fail, if subdirectory doesn't exist. @@ -300,13 +300,13 @@ test_config_write_to_data_subdir(void *arg) // equal to the original string. tt_assert(!write_to_data_subdir(subdir, fname, str, NULL)); cp = read_file_to_str(filepath, 0, NULL); - tt_str_op(cp,==, str); + tt_str_op(cp,OP_EQ, str); tor_free(cp);

// A second write operation should overwrite the old content. tt_assert(!write_to_data_subdir(subdir, fname, str, NULL)); cp = read_file_to_str(filepath, 0, NULL); - tt_str_op(cp,==, str); + tt_str_op(cp,OP_EQ, str); tor_free(cp);

done: @@ -331,7 +331,7 @@ good_bridge_line_test(const char *string, const char *test_addrport,

/* test addrport */ tmp = tor_strdup(fmt_addrport(&bridge_line->addr, bridge_line->port)); - tt_str_op(test_addrport,==, tmp); + tt_str_op(test_addrport,OP_EQ, tmp); tor_free(tmp);

/* If we were asked to validate a digest, but we did not get a @@ -349,7 +349,7 @@ good_bridge_line_test(const char *string, const char *test_addrport, if (test_digest) { tmp = tor_strdup(hex_str(bridge_line->digest, DIGEST_LEN)); tor_strlower(tmp); - tt_str_op(test_digest,==, tmp); + tt_str_op(test_digest,OP_EQ, tmp); tor_free(tmp); }

@@ -360,7 +360,7 @@ good_bridge_line_test(const char *string, const char *test_addrport, if (!test_transport && bridge_line->transport_name) tt_assert(0); if (test_transport) - tt_str_op(test_transport,==, bridge_line->transport_name); + tt_str_op(test_transport,OP_EQ, bridge_line->transport_name);

/* Validate the SOCKS argument smartlist. */ if (test_socks_args && !bridge_line->socks_args) @@ -839,7 +839,7 @@ test_config_fix_my_family(void *arg) TT_FAIL(("options_validate failed: %s", err)); }

- tt_str_op(options->MyFamily,==, "$1111111111111111111111111111111111111111, " + tt_str_op(options->MyFamily,OP_EQ, "$1111111111111111111111111111111111111111, " "$1111111111111111111111111111111111111112, " "$1111111111111111111111111111111111111113");

diff --git a/src/test/test_containers.c b/src/test/test_containers.c index d0972dd..89eb1a2 100644 --- a/src/test/test_containers.c +++ b/src/test/test_containers.c @@ -62,18 +62,18 @@ test_container_smartlist_basic(void *arg) smartlist_insert(sl, 1, v22); smartlist_insert(sl, 0, v0); smartlist_insert(sl, 5, v555); - tt_ptr_op(v0,==, smartlist_get(sl,0)); - tt_ptr_op(v1,==, smartlist_get(sl,1)); - tt_ptr_op(v22,==, smartlist_get(sl,2)); - tt_ptr_op(v3,==, smartlist_get(sl,3)); - tt_ptr_op(v4,==, smartlist_get(sl,4)); - tt_ptr_op(v555,==, smartlist_get(sl,5)); + tt_ptr_op(v0,OP_EQ, smartlist_get(sl,0)); + tt_ptr_op(v1,OP_EQ, smartlist_get(sl,1)); + tt_ptr_op(v22,OP_EQ, smartlist_get(sl,2)); + tt_ptr_op(v3,OP_EQ, smartlist_get(sl,3)); + tt_ptr_op(v4,OP_EQ, smartlist_get(sl,4)); + tt_ptr_op(v555,OP_EQ, smartlist_get(sl,5)); /* Try deleting in the middle. */ smartlist_del(sl, 1); - tt_ptr_op(v555,==, smartlist_get(sl, 1)); + tt_ptr_op(v555,OP_EQ, smartlist_get(sl, 1)); /* Try deleting at the end. */ smartlist_del(sl, 4); - tt_int_op(4,==, smartlist_len(sl)); + tt_int_op(4,OP_EQ, smartlist_len(sl));

/* test isin. */ tt_assert(smartlist_contains(sl, v3)); @@ -101,119 +101,119 @@ test_container_smartlist_strings(void *arg)

/* Test split and join */ (void)arg; - tt_int_op(0,==, smartlist_len(sl)); + tt_int_op(0,OP_EQ, smartlist_len(sl)); smartlist_split_string(sl, "abc", ":", 0, 0); - tt_int_op(1,==, smartlist_len(sl)); - tt_str_op("abc",==, smartlist_get(sl, 0)); + tt_int_op(1,OP_EQ, smartlist_len(sl)); + tt_str_op("abc",OP_EQ, smartlist_get(sl, 0)); smartlist_split_string(sl, "a::bc::", "::", 0, 0); - tt_int_op(4,==, smartlist_len(sl)); - tt_str_op("a",==, smartlist_get(sl, 1)); - tt_str_op("bc",==, smartlist_get(sl, 2)); - tt_str_op("",==, smartlist_get(sl, 3)); + tt_int_op(4,OP_EQ, smartlist_len(sl)); + tt_str_op("a",OP_EQ, smartlist_get(sl, 1)); + tt_str_op("bc",OP_EQ, smartlist_get(sl, 2)); + tt_str_op("",OP_EQ, smartlist_get(sl, 3)); cp_alloc = smartlist_join_strings(sl, "", 0, NULL); - tt_str_op(cp_alloc,==, "abcabc"); + tt_str_op(cp_alloc,OP_EQ, "abcabc"); tor_free(cp_alloc); cp_alloc = smartlist_join_strings(sl, "!", 0, NULL); - tt_str_op(cp_alloc,==, "abc!a!bc!"); + tt_str_op(cp_alloc,OP_EQ, "abc!a!bc!"); tor_free(cp_alloc); cp_alloc = smartlist_join_strings(sl, "XY", 0, NULL); - tt_str_op(cp_alloc,==, "abcXYaXYbcXY"); + tt_str_op(cp_alloc,OP_EQ, "abcXYaXYbcXY"); tor_free(cp_alloc); cp_alloc = smartlist_join_strings(sl, "XY", 1, NULL); - tt_str_op(cp_alloc,==, "abcXYaXYbcXYXY"); + tt_str_op(cp_alloc,OP_EQ, "abcXYaXYbcXYXY"); tor_free(cp_alloc); cp_alloc = smartlist_join_strings(sl, "", 1, NULL); - tt_str_op(cp_alloc,==, "abcabc"); + tt_str_op(cp_alloc,OP_EQ, "abcabc"); tor_free(cp_alloc);

smartlist_split_string(sl, "/def/ /ghijk", "/", 0, 0); - tt_int_op(8,==, smartlist_len(sl)); - tt_str_op("",==, smartlist_get(sl, 4)); - tt_str_op("def",==, smartlist_get(sl, 5)); - tt_str_op(" ",==, smartlist_get(sl, 6)); - tt_str_op("ghijk",==, smartlist_get(sl, 7)); + tt_int_op(8,OP_EQ, smartlist_len(sl)); + tt_str_op("",OP_EQ, smartlist_get(sl, 4)); + tt_str_op("def",OP_EQ, smartlist_get(sl, 5)); + tt_str_op(" ",OP_EQ, smartlist_get(sl, 6)); + tt_str_op("ghijk",OP_EQ, smartlist_get(sl, 7)); SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); smartlist_clear(sl);

smartlist_split_string(sl, "a,bbd,cdef", ",", SPLIT_SKIP_SPACE, 0); - tt_int_op(3,==, smartlist_len(sl)); - tt_str_op("a",==, smartlist_get(sl,0)); - tt_str_op("bbd",==, smartlist_get(sl,1)); - tt_str_op("cdef",==, smartlist_get(sl,2)); + tt_int_op(3,OP_EQ, smartlist_len(sl)); + tt_str_op("a",OP_EQ, smartlist_get(sl,0)); + tt_str_op("bbd",OP_EQ, smartlist_get(sl,1)); + tt_str_op("cdef",OP_EQ, smartlist_get(sl,2)); smartlist_split_string(sl, " z <> zhasd <> <> bnud<> ", "<>", SPLIT_SKIP_SPACE, 0); - tt_int_op(8,==, smartlist_len(sl)); - tt_str_op("z",==, smartlist_get(sl,3)); - tt_str_op("zhasd",==, smartlist_get(sl,4)); - tt_str_op("",==, smartlist_get(sl,5)); - tt_str_op("bnud",==, smartlist_get(sl,6)); - tt_str_op("",==, smartlist_get(sl,7)); + tt_int_op(8,OP_EQ, smartlist_len(sl)); + tt_str_op("z",OP_EQ, smartlist_get(sl,3)); + tt_str_op("zhasd",OP_EQ, smartlist_get(sl,4)); + tt_str_op("",OP_EQ, smartlist_get(sl,5)); + tt_str_op("bnud",OP_EQ, smartlist_get(sl,6)); + tt_str_op("",OP_EQ, smartlist_get(sl,7));

SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); smartlist_clear(sl);

smartlist_split_string(sl, " ab\tc \td ef ", NULL, SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0); - tt_int_op(4,==, smartlist_len(sl)); - tt_str_op("ab",==, smartlist_get(sl,0)); - tt_str_op("c",==, smartlist_get(sl,1)); - tt_str_op("d",==, smartlist_get(sl,2)); - tt_str_op("ef",==, smartlist_get(sl,3)); + tt_int_op(4,OP_EQ, smartlist_len(sl)); + tt_str_op("ab",OP_EQ, smartlist_get(sl,0)); + tt_str_op("c",OP_EQ, smartlist_get(sl,1)); + tt_str_op("d",OP_EQ, smartlist_get(sl,2)); + tt_str_op("ef",OP_EQ, smartlist_get(sl,3)); smartlist_split_string(sl, "ghi\tj", NULL, SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0); - tt_int_op(6,==, smartlist_len(sl)); - tt_str_op("ghi",==, smartlist_get(sl,4)); - tt_str_op("j",==, smartlist_get(sl,5)); + tt_int_op(6,OP_EQ, smartlist_len(sl)); + tt_str_op("ghi",OP_EQ, smartlist_get(sl,4)); + tt_str_op("j",OP_EQ, smartlist_get(sl,5));

SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); smartlist_clear(sl);

cp_alloc = smartlist_join_strings(sl, "XY", 0, NULL); - tt_str_op(cp_alloc,==, ""); + tt_str_op(cp_alloc,OP_EQ, ""); tor_free(cp_alloc); cp_alloc = smartlist_join_strings(sl, "XY", 1, NULL); - tt_str_op(cp_alloc,==, "XY"); + tt_str_op(cp_alloc,OP_EQ, "XY"); tor_free(cp_alloc);

smartlist_split_string(sl, " z <> zhasd <> <> bnud<> ", "<>", SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0); - tt_int_op(3,==, smartlist_len(sl)); - tt_str_op("z",==, smartlist_get(sl, 0)); - tt_str_op("zhasd",==, smartlist_get(sl, 1)); - tt_str_op("bnud",==, smartlist_get(sl, 2)); + tt_int_op(3,OP_EQ, smartlist_len(sl)); + tt_str_op("z",OP_EQ, smartlist_get(sl, 0)); + tt_str_op("zhasd",OP_EQ, smartlist_get(sl, 1)); + tt_str_op("bnud",OP_EQ, smartlist_get(sl, 2)); smartlist_split_string(sl, " z <> zhasd <> <> bnud<> ", "<>", SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 2); - tt_int_op(5,==, smartlist_len(sl)); - tt_str_op("z",==, smartlist_get(sl, 3)); - tt_str_op("zhasd <> <> bnud<>",==, smartlist_get(sl, 4)); + tt_int_op(5,OP_EQ, smartlist_len(sl)); + tt_str_op("z",OP_EQ, smartlist_get(sl, 3)); + tt_str_op("zhasd <> <> bnud<>",OP_EQ, smartlist_get(sl, 4)); SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); smartlist_clear(sl);

smartlist_split_string(sl, "abcd\n", "\n", SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0); - tt_int_op(1,==, smartlist_len(sl)); - tt_str_op("abcd",==, smartlist_get(sl, 0)); + tt_int_op(1,OP_EQ, smartlist_len(sl)); + tt_str_op("abcd",OP_EQ, smartlist_get(sl, 0)); smartlist_split_string(sl, "efgh", "\n", SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0); - tt_int_op(2,==, smartlist_len(sl)); - tt_str_op("efgh",==, smartlist_get(sl, 1)); + tt_int_op(2,OP_EQ, smartlist_len(sl)); + tt_str_op("efgh",OP_EQ, smartlist_get(sl, 1));

SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); smartlist_clear(sl);

/* Test swapping, shuffling, and sorting. */ smartlist_split_string(sl, "the,onion,router,by,arma,and,nickm", ",", 0, 0); - tt_int_op(7,==, smartlist_len(sl)); + tt_int_op(7,OP_EQ, smartlist_len(sl)); smartlist_sort(sl, compare_strs_); cp_alloc = smartlist_join_strings(sl, ",", 0, NULL); - tt_str_op(cp_alloc,==, "and,arma,by,nickm,onion,router,the"); + tt_str_op(cp_alloc,OP_EQ, "and,arma,by,nickm,onion,router,the"); tor_free(cp_alloc); smartlist_swap(sl, 1, 5); cp_alloc = smartlist_join_strings(sl, ",", 0, NULL); - tt_str_op(cp_alloc,==, "and,router,by,nickm,onion,arma,the"); + tt_str_op(cp_alloc,OP_EQ, "and,router,by,nickm,onion,arma,the"); tor_free(cp_alloc); smartlist_shuffle(sl); - tt_int_op(7,==, smartlist_len(sl)); + tt_int_op(7,OP_EQ, smartlist_len(sl)); tt_assert(smartlist_contains_string(sl, "and")); tt_assert(smartlist_contains_string(sl, "router")); tt_assert(smartlist_contains_string(sl, "by")); @@ -224,69 +224,69 @@ test_container_smartlist_strings(void *arg)

/* Test bsearch. */ smartlist_sort(sl, compare_strs_); - tt_str_op("nickm",==, smartlist_bsearch(sl, "zNicKM", + tt_str_op("nickm",OP_EQ, smartlist_bsearch(sl, "zNicKM", cmp_without_first_)); - tt_str_op("and",==, + tt_str_op("and",OP_EQ, smartlist_bsearch(sl, " AND", cmp_without_first_)); - tt_ptr_op(NULL,==, smartlist_bsearch(sl, " ANz", cmp_without_first_)); + tt_ptr_op(NULL,OP_EQ, smartlist_bsearch(sl, " ANz", cmp_without_first_));

/* Test bsearch_idx */ { int f; smartlist_t *tmp = NULL;

- tt_int_op(0,==,smartlist_bsearch_idx(sl," aaa",cmp_without_first_,&f)); - tt_int_op(f,==, 0); - tt_int_op(0,==, smartlist_bsearch_idx(sl," and",cmp_without_first_,&f)); - tt_int_op(f,==, 1); - tt_int_op(1,==, smartlist_bsearch_idx(sl," arm",cmp_without_first_,&f)); - tt_int_op(f,==, 0); - tt_int_op(1,==, smartlist_bsearch_idx(sl," arma",cmp_without_first_,&f)); - tt_int_op(f,==, 1); - tt_int_op(2,==, smartlist_bsearch_idx(sl," armb",cmp_without_first_,&f)); - tt_int_op(f,==, 0); - tt_int_op(7,==, smartlist_bsearch_idx(sl," zzzz",cmp_without_first_,&f)); - tt_int_op(f,==, 0); + tt_int_op(0,OP_EQ,smartlist_bsearch_idx(sl," aaa",cmp_without_first_,&f)); + tt_int_op(f,OP_EQ, 0); + tt_int_op(0,OP_EQ, smartlist_bsearch_idx(sl," and",cmp_without_first_,&f)); + tt_int_op(f,OP_EQ, 1); + tt_int_op(1,OP_EQ, smartlist_bsearch_idx(sl," arm",cmp_without_first_,&f)); + tt_int_op(f,OP_EQ, 0); + tt_int_op(1,OP_EQ, smartlist_bsearch_idx(sl," arma",cmp_without_first_,&f)); + tt_int_op(f,OP_EQ, 1); + tt_int_op(2,OP_EQ, smartlist_bsearch_idx(sl," armb",cmp_without_first_,&f)); + tt_int_op(f,OP_EQ, 0); + tt_int_op(7,OP_EQ, smartlist_bsearch_idx(sl," zzzz",cmp_without_first_,&f)); + tt_int_op(f,OP_EQ, 0);

/* Test trivial cases for list of length 0 or 1 */ tmp = smartlist_new(); - tt_int_op(0,==, smartlist_bsearch_idx(tmp, "foo", + tt_int_op(0,OP_EQ, smartlist_bsearch_idx(tmp, "foo", compare_strs_for_bsearch_, &f)); - tt_int_op(f,==, 0); + tt_int_op(f,OP_EQ, 0); smartlist_insert(tmp, 0, (void *)("bar")); - tt_int_op(1,==, smartlist_bsearch_idx(tmp, "foo", + tt_int_op(1,OP_EQ, smartlist_bsearch_idx(tmp, "foo", compare_strs_for_bsearch_, &f)); - tt_int_op(f,==, 0); - tt_int_op(0,==, smartlist_bsearch_idx(tmp, "aaa", + tt_int_op(f,OP_EQ, 0); + tt_int_op(0,OP_EQ, smartlist_bsearch_idx(tmp, "aaa", compare_strs_for_bsearch_, &f)); - tt_int_op(f,==, 0); - tt_int_op(0,==, smartlist_bsearch_idx(tmp, "bar", + tt_int_op(f,OP_EQ, 0); + tt_int_op(0,OP_EQ, smartlist_bsearch_idx(tmp, "bar", compare_strs_for_bsearch_, &f)); - tt_int_op(f,==, 1); + tt_int_op(f,OP_EQ, 1); /* ... and one for length 2 */ smartlist_insert(tmp, 1, (void *)("foo")); - tt_int_op(1,==, smartlist_bsearch_idx(tmp, "foo", + tt_int_op(1,OP_EQ, smartlist_bsearch_idx(tmp, "foo", compare_strs_for_bsearch_, &f)); - tt_int_op(f,==, 1); - tt_int_op(2,==, smartlist_bsearch_idx(tmp, "goo", + tt_int_op(f,OP_EQ, 1); + tt_int_op(2,OP_EQ, smartlist_bsearch_idx(tmp, "goo", compare_strs_for_bsearch_, &f)); - tt_int_op(f,==, 0); + tt_int_op(f,OP_EQ, 0); smartlist_free(tmp); }

/* Test reverse() and pop_last() */ smartlist_reverse(sl); cp_alloc = smartlist_join_strings(sl, ",", 0, NULL); - tt_str_op(cp_alloc,==, "the,router,onion,nickm,by,arma,and"); + tt_str_op(cp_alloc,OP_EQ, "the,router,onion,nickm,by,arma,and"); tor_free(cp_alloc); cp_alloc = smartlist_pop_last(sl); - tt_str_op(cp_alloc,==, "and"); + tt_str_op(cp_alloc,OP_EQ, "and"); tor_free(cp_alloc); - tt_int_op(smartlist_len(sl),==, 6); + tt_int_op(smartlist_len(sl),OP_EQ, 6); SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); smartlist_clear(sl); cp_alloc = smartlist_pop_last(sl); - tt_ptr_op(cp_alloc,==, NULL); + tt_ptr_op(cp_alloc,OP_EQ, NULL);

/* Test uniq() */ smartlist_split_string(sl, @@ -295,7 +295,7 @@ test_container_smartlist_strings(void *arg) smartlist_sort(sl, compare_strs_); smartlist_uniq(sl, compare_strs_, tor_free_); cp_alloc = smartlist_join_strings(sl, ",", 0, NULL); - tt_str_op(cp_alloc,==, "50,a,canal,man,noon,panama,plan,radar"); + tt_str_op(cp_alloc,OP_EQ, "50,a,canal,man,noon,panama,plan,radar"); tor_free(cp_alloc);

/* Test contains_string, contains_string_case and contains_int_as_string */ @@ -331,17 +331,17 @@ test_container_smartlist_strings(void *arg) "Some say the Earth will end in ice and some in fire", " ", 0, 0); cp = smartlist_get(sl, 4); - tt_str_op(cp,==, "will"); + tt_str_op(cp,OP_EQ, "will"); smartlist_add(sl, cp); smartlist_remove(sl, cp); tor_free(cp); cp_alloc = smartlist_join_strings(sl, ",", 0, NULL); - tt_str_op(cp_alloc,==, "Some,say,the,Earth,fire,end,in,ice,and,some,in"); + tt_str_op(cp_alloc,OP_EQ, "Some,say,the,Earth,fire,end,in,ice,and,some,in"); tor_free(cp_alloc); smartlist_string_remove(sl, "in"); cp_alloc = smartlist_join_strings2(sl, "+XX", 1, 0, &sz); - tt_str_op(cp_alloc,==, "Some+say+the+Earth+fire+end+some+ice+and"); - tt_int_op((int)sz,==, 40); + tt_str_op(cp_alloc,OP_EQ, "Some+say+the+Earth+fire+end+some+ice+and"); + tt_int_op((int)sz,OP_EQ, 40);

done:

@@ -369,7 +369,7 @@ test_container_smartlist_overlap(void *arg) /* add_all */ smartlist_add_all(ints, odds); smartlist_add_all(ints, evens); - tt_int_op(smartlist_len(ints),==, 10); + tt_int_op(smartlist_len(ints),OP_EQ, 10);

smartlist_add(primes, (void*)2); smartlist_add(primes, (void*)3); @@ -385,7 +385,7 @@ test_container_smartlist_overlap(void *arg) /* intersect */ smartlist_add_all(sl, odds); smartlist_intersect(sl, primes); - tt_int_op(smartlist_len(sl),==, 3); + tt_int_op(smartlist_len(sl),OP_EQ, 3); tt_assert(smartlist_contains(sl, (void*)3)); tt_assert(smartlist_contains(sl, (void*)5)); tt_assert(smartlist_contains(sl, (void*)7)); @@ -393,7 +393,7 @@ test_container_smartlist_overlap(void *arg) /* subtract */ smartlist_add_all(sl, primes); smartlist_subtract(sl, odds); - tt_int_op(smartlist_len(sl),==, 1); + tt_int_op(smartlist_len(sl),OP_EQ, 1); tt_assert(smartlist_contains(sl, (void*)2));

done: @@ -415,23 +415,23 @@ test_container_smartlist_digests(void *arg) smartlist_add(sl, tor_memdup("AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN)); smartlist_add(sl, tor_memdup("\00090AAB2AAAAaasdAAAAA", DIGEST_LEN)); smartlist_add(sl, tor_memdup("\00090AAB2AAAAaasdAAAAA", DIGEST_LEN)); - tt_int_op(0,==, smartlist_contains_digest(NULL, "AAAAAAAAAAAAAAAAAAAA")); + tt_int_op(0,OP_EQ, smartlist_contains_digest(NULL, "AAAAAAAAAAAAAAAAAAAA")); tt_assert(smartlist_contains_digest(sl, "AAAAAAAAAAAAAAAAAAAA")); tt_assert(smartlist_contains_digest(sl, "\00090AAB2AAAAaasdAAAAA")); - tt_int_op(0,==, smartlist_contains_digest(sl, "\00090AAB2AAABaasdAAAAA")); + tt_int_op(0,OP_EQ, smartlist_contains_digest(sl, "\00090AAB2AAABaasdAAAAA"));

/* sort digests */ smartlist_sort_digests(sl); - tt_mem_op(smartlist_get(sl, 0),==, "\00090AAB2AAAAaasdAAAAA", DIGEST_LEN); - tt_mem_op(smartlist_get(sl, 1),==, "\00090AAB2AAAAaasdAAAAA", DIGEST_LEN); - tt_mem_op(smartlist_get(sl, 2),==, "AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN); - tt_int_op(3,==, smartlist_len(sl)); + tt_mem_op(smartlist_get(sl, 0),OP_EQ, "\00090AAB2AAAAaasdAAAAA", DIGEST_LEN); + tt_mem_op(smartlist_get(sl, 1),OP_EQ, "\00090AAB2AAAAaasdAAAAA", DIGEST_LEN); + tt_mem_op(smartlist_get(sl, 2),OP_EQ, "AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN); + tt_int_op(3,OP_EQ, smartlist_len(sl));

/* uniq_digests */ smartlist_uniq_digests(sl); - tt_int_op(2,==, smartlist_len(sl)); - tt_mem_op(smartlist_get(sl, 0),==, "\00090AAB2AAAAaasdAAAAA", DIGEST_LEN); - tt_mem_op(smartlist_get(sl, 1),==, "AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN); + tt_int_op(2,OP_EQ, smartlist_len(sl)); + tt_mem_op(smartlist_get(sl, 0),OP_EQ, "\00090AAB2AAAAaasdAAAAA", DIGEST_LEN); + tt_mem_op(smartlist_get(sl, 1),OP_EQ, "AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN);

done: SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); @@ -463,7 +463,7 @@ test_container_smartlist_join(void *arg) sl2, char *, cp2, strcmp(cp1,cp2), smartlist_add(sl3, cp2)) { - tt_str_op(cp1,==, cp2); + tt_str_op(cp1,OP_EQ, cp2); smartlist_add(sl4, cp1); } SMARTLIST_FOREACH_JOIN_END(cp1, cp2);

@@ -474,10 +474,10 @@ test_container_smartlist_join(void *arg) tt_assert(smartlist_contains(sl, cp) && smartlist_contains_string(sl2, cp))); joined = smartlist_join_strings(sl3, ",", 0, NULL); - tt_str_op(joined,==, "Anemias,Anemias,Crossbowmen,Work"); + tt_str_op(joined,OP_EQ, "Anemias,Anemias,Crossbowmen,Work"); tor_free(joined); joined = smartlist_join_strings(sl4, ",", 0, NULL); - tt_str_op(joined,==, "Ambush,Anchorman,Anchorman,Bacon,Inhumane,Insurance," + tt_str_op(joined,OP_EQ, "Ambush,Anchorman,Anchorman,Bacon,Inhumane,Insurance," "Knish,Know,Manners,Manners,Maraschinos,Wombats,Wombats"); tor_free(joined);

@@ -612,7 +612,7 @@ test_container_digestset(void *arg) if (digestset_contains(set, d)) ++false_positives; } - tt_int_op(50, >, false_positives); /* Should be far lower. */ + tt_int_op(50, OP_GT, false_positives); /* Should be far lower. */

done: if (set) @@ -675,31 +675,31 @@ test_container_pqueue(void *arg)

OK();

- tt_int_op(smartlist_len(sl),==, 11); - tt_ptr_op(smartlist_get(sl, 0),==, &apples); - tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &apples); - tt_int_op(smartlist_len(sl),==, 10); + tt_int_op(smartlist_len(sl),OP_EQ, 11); + tt_ptr_op(smartlist_get(sl, 0),OP_EQ, &apples); + tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &apples); + tt_int_op(smartlist_len(sl),OP_EQ, 10); OK(); - tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &cows); - tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &daschunds); + tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &cows); + tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &daschunds); smartlist_pqueue_add(sl, cmp, offset, &chinchillas); OK(); smartlist_pqueue_add(sl, cmp, offset, &fireflies); OK(); - tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &chinchillas); - tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &eggplants); - tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &fireflies); + tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &chinchillas); + tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &eggplants); + tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &fireflies); OK(); - tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &fish); - tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &frogs); - tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &lobsters); - tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &roquefort); + tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &fish); + tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &frogs); + tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &lobsters); + tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &roquefort); OK(); - tt_int_op(smartlist_len(sl),==, 3); - tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &squid); - tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &weissbier); - tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &zebras); - tt_int_op(smartlist_len(sl),==, 0); + tt_int_op(smartlist_len(sl),OP_EQ, 3); + tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &squid); + tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &weissbier); + tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &zebras); + tt_int_op(smartlist_len(sl),OP_EQ, 0); OK();

/* Now test remove. */ @@ -709,21 +709,21 @@ test_container_pqueue(void *arg) smartlist_pqueue_add(sl, cmp, offset, &apples); smartlist_pqueue_add(sl, cmp, offset, &squid); smartlist_pqueue_add(sl, cmp, offset, &zebras); - tt_int_op(smartlist_len(sl),==, 6); + tt_int_op(smartlist_len(sl),OP_EQ, 6); OK(); smartlist_pqueue_remove(sl, cmp, offset, &zebras); - tt_int_op(smartlist_len(sl),==, 5); + tt_int_op(smartlist_len(sl),OP_EQ, 5); OK(); smartlist_pqueue_remove(sl, cmp, offset, &cows); - tt_int_op(smartlist_len(sl),==, 4); + tt_int_op(smartlist_len(sl),OP_EQ, 4); OK(); smartlist_pqueue_remove(sl, cmp, offset, &apples); - tt_int_op(smartlist_len(sl),==, 3); + tt_int_op(smartlist_len(sl),OP_EQ, 3); OK(); - tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &fish); - tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &frogs); - tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),==, &squid); - tt_int_op(smartlist_len(sl),==, 0); + tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &fish); + tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &frogs); + tt_ptr_op(smartlist_pqueue_pop(sl, cmp, offset),OP_EQ, &squid); + tt_int_op(smartlist_len(sl),OP_EQ, 0); OK();

#undef OK @@ -755,30 +755,30 @@ test_container_strmap(void *arg) (void)arg; map = strmap_new(); tt_assert(map); - tt_int_op(strmap_size(map),==, 0); + tt_int_op(strmap_size(map),OP_EQ, 0); tt_assert(strmap_isempty(map)); v = strmap_set(map, "K1", v99); - tt_ptr_op(v,==, NULL); + tt_ptr_op(v,OP_EQ, NULL); tt_assert(!strmap_isempty(map)); v = strmap_set(map, "K2", v101); - tt_ptr_op(v,==, NULL); + tt_ptr_op(v,OP_EQ, NULL); v = strmap_set(map, "K1", v100); - tt_ptr_op(v,==, v99); - tt_ptr_op(strmap_get(map,"K1"),==, v100); - tt_ptr_op(strmap_get(map,"K2"),==, v101); - tt_ptr_op(strmap_get(map,"K-not-there"),==, NULL); + tt_ptr_op(v,OP_EQ, v99); + tt_ptr_op(strmap_get(map,"K1"),OP_EQ, v100); + tt_ptr_op(strmap_get(map,"K2"),OP_EQ, v101); + tt_ptr_op(strmap_get(map,"K-not-there"),OP_EQ, NULL); strmap_assert_ok(map);

v = strmap_remove(map,"K2"); strmap_assert_ok(map); - tt_ptr_op(v,==, v101); - tt_ptr_op(strmap_get(map,"K2"),==, NULL); - tt_ptr_op(strmap_remove(map,"K2"),==, NULL); + tt_ptr_op(v,OP_EQ, v101); + tt_ptr_op(strmap_get(map,"K2"),OP_EQ, NULL); + tt_ptr_op(strmap_remove(map,"K2"),OP_EQ, NULL);

strmap_set(map, "K2", v101); strmap_set(map, "K3", v102); strmap_set(map, "K4", v103); - tt_int_op(strmap_size(map),==, 4); + tt_int_op(strmap_size(map),OP_EQ, 4); strmap_assert_ok(map); strmap_set(map, "K5", v104); strmap_set(map, "K6", v105); @@ -790,7 +790,7 @@ test_container_strmap(void *arg) while (!strmap_iter_done(iter)) { strmap_iter_get(iter,&k,&v); smartlist_add(found_keys, tor_strdup(k)); - tt_ptr_op(v,==, strmap_get(map, k)); + tt_ptr_op(v,OP_EQ, strmap_get(map, k));

if (!strcmp(k, "K2")) { iter = strmap_iter_next_rmv(map,iter); @@ -800,12 +800,12 @@ test_container_strmap(void *arg) }

/* Make sure we removed K2, but not the others. */ - tt_ptr_op(strmap_get(map, "K2"),==, NULL); - tt_ptr_op(strmap_get(map, "K5"),==, v104); + tt_ptr_op(strmap_get(map, "K2"),OP_EQ, NULL); + tt_ptr_op(strmap_get(map, "K5"),OP_EQ, v104); /* Make sure we visited everyone once */ smartlist_sort_strings(found_keys); visited = smartlist_join_strings(found_keys, ":", 0, NULL); - tt_str_op(visited,==, "K1:K2:K3:K4:K5:K6"); + tt_str_op(visited,OP_EQ, "K1:K2:K3:K4:K5:K6");

strmap_assert_ok(map); /* Clean up after ourselves. */ @@ -815,13 +815,13 @@ test_container_strmap(void *arg) /* Now try some lc functions. */ map = strmap_new(); strmap_set_lc(map,"Ab.C", v1); - tt_ptr_op(strmap_get(map,"ab.c"),==, v1); + tt_ptr_op(strmap_get(map,"ab.c"),OP_EQ, v1); strmap_assert_ok(map); - tt_ptr_op(strmap_get_lc(map,"AB.C"),==, v1); - tt_ptr_op(strmap_get(map,"AB.C"),==, NULL); - tt_ptr_op(strmap_remove_lc(map,"aB.C"),==, v1); + tt_ptr_op(strmap_get_lc(map,"AB.C"),OP_EQ, v1); + tt_ptr_op(strmap_get(map,"AB.C"),OP_EQ, NULL); + tt_ptr_op(strmap_remove_lc(map,"aB.C"),OP_EQ, v1); strmap_assert_ok(map); - tt_ptr_op(strmap_get_lc(map,"AB.C"),==, NULL); + tt_ptr_op(strmap_get_lc(map,"AB.C"),OP_EQ, NULL);

done: if (map) @@ -853,41 +853,41 @@ test_container_order_functions(void *arg)

(void)arg; lst[n++] = 12; - tt_int_op(12,==, median()); /* 12 */ + tt_int_op(12,OP_EQ, median()); /* 12 */ lst[n++] = 77; //smartlist_shuffle(sl); - tt_int_op(12,==, median()); /* 12, 77 */ + tt_int_op(12,OP_EQ, median()); /* 12, 77 */ lst[n++] = 77; //smartlist_shuffle(sl); - tt_int_op(77,==, median()); /* 12, 77, 77 */ + tt_int_op(77,OP_EQ, median()); /* 12, 77, 77 */ lst[n++] = 24; - tt_int_op(24,==, median()); /* 12,24,77,77 */ + tt_int_op(24,OP_EQ, median()); /* 12,24,77,77 */ lst[n++] = 60; lst[n++] = 12; lst[n++] = 25; //smartlist_shuffle(sl); - tt_int_op(25,==, median()); /* 12,12,24,25,60,77,77 */ + tt_int_op(25,OP_EQ, median()); /* 12,12,24,25,60,77,77 */ #undef median

#define third_quartile() third_quartile_uint32(lst2, n)

n = 0; lst2[n++] = 1; - tt_int_op(1,==, third_quartile()); /* ~1~ */ + tt_int_op(1,OP_EQ, third_quartile()); /* ~1~ */ lst2[n++] = 2; - tt_int_op(2,==, third_quartile()); /* 1, ~2~ */ + tt_int_op(2,OP_EQ, third_quartile()); /* 1, ~2~ */ lst2[n++] = 3; lst2[n++] = 4; lst2[n++] = 5; - tt_int_op(4,==, third_quartile()); /* 1, 2, 3, ~4~, 5 */ + tt_int_op(4,OP_EQ, third_quartile()); /* 1, 2, 3, ~4~, 5 */ lst2[n++] = 6; lst2[n++] = 7; lst2[n++] = 8; lst2[n++] = 9; - tt_int_op(7,==, third_quartile()); /* 1, 2, 3, 4, 5, 6, ~7~, 8, 9 */ + tt_int_op(7,OP_EQ, third_quartile()); /* 1, 2, 3, 4, 5, 6, ~7~, 8, 9 */ lst2[n++] = 10; lst2[n++] = 11; - tt_int_op(9,==, third_quartile()); /* 1, 2, 3, 4, 5, 6, 7, 8, ~9~, 10, 11 */ + tt_int_op(9,OP_EQ, third_quartile()); /* 1, 2, 3, 4, 5, 6, 7, 8, ~9~, 10, 11 */

#undef third_quartile

@@ -911,26 +911,26 @@ test_container_di_map(void *arg) (void)arg;

/* Try searching on an empty map. */ - tt_ptr_op(NULL, ==, dimap_search(map, key1, NULL)); - tt_ptr_op(NULL, ==, dimap_search(map, key2, NULL)); - tt_ptr_op(v3, ==, dimap_search(map, key2, v3)); + tt_ptr_op(NULL, OP_EQ, dimap_search(map, key1, NULL)); + tt_ptr_op(NULL, OP_EQ, dimap_search(map, key2, NULL)); + tt_ptr_op(v3, OP_EQ, dimap_search(map, key2, v3)); dimap_free(map, NULL); map = NULL;

/* Add a single entry. */ dimap_add_entry(&map, key1, v1); - tt_ptr_op(NULL, ==, dimap_search(map, key2, NULL)); - tt_ptr_op(v3, ==, dimap_search(map, key2, v3)); - tt_ptr_op(v1, ==, dimap_search(map, key1, NULL)); + tt_ptr_op(NULL, OP_EQ, dimap_search(map, key2, NULL)); + tt_ptr_op(v3, OP_EQ, dimap_search(map, key2, v3)); + tt_ptr_op(v1, OP_EQ, dimap_search(map, key1, NULL));

/* Now try it with three entries in the map. */ dimap_add_entry(&map, key2, v2); dimap_add_entry(&map, key3, v3); - tt_ptr_op(v1, ==, dimap_search(map, key1, NULL)); - tt_ptr_op(v2, ==, dimap_search(map, key2, NULL)); - tt_ptr_op(v3, ==, dimap_search(map, key3, NULL)); - tt_ptr_op(NULL, ==, dimap_search(map, key4, NULL)); - tt_ptr_op(v1, ==, dimap_search(map, key4, v1)); + tt_ptr_op(v1, OP_EQ, dimap_search(map, key1, NULL)); + tt_ptr_op(v2, OP_EQ, dimap_search(map, key2, NULL)); + tt_ptr_op(v3, OP_EQ, dimap_search(map, key3, NULL)); + tt_ptr_op(NULL, OP_EQ, dimap_search(map, key4, NULL)); + tt_ptr_op(v1, OP_EQ, dimap_search(map, key4, v1));

done: tor_free(v1); @@ -959,7 +959,7 @@ test_container_fp_pair_map(void *arg) (void)arg; map = fp_pair_map_new(); tt_assert(map); - tt_int_op(fp_pair_map_size(map),==, 0); + tt_int_op(fp_pair_map_size(map),OP_EQ, 0); tt_assert(fp_pair_map_isempty(map));

memset(fp1.first, 0x11, DIGEST_LEN); @@ -976,27 +976,27 @@ test_container_fp_pair_map(void *arg) memset(fp6.second, 0x62, DIGEST_LEN);

v = fp_pair_map_set(map, &fp1, v99); - tt_ptr_op(v, ==, NULL); + tt_ptr_op(v, OP_EQ, NULL); tt_assert(!fp_pair_map_isempty(map)); v = fp_pair_map_set(map, &fp2, v101); - tt_ptr_op(v, ==, NULL); + tt_ptr_op(v, OP_EQ, NULL); v = fp_pair_map_set(map, &fp1, v100); - tt_ptr_op(v, ==, v99); - tt_ptr_op(fp_pair_map_get(map, &fp1),==, v100); - tt_ptr_op(fp_pair_map_get(map, &fp2),==, v101); - tt_ptr_op(fp_pair_map_get(map, &fp3),==, NULL); + tt_ptr_op(v, OP_EQ, v99); + tt_ptr_op(fp_pair_map_get(map, &fp1),OP_EQ, v100); + tt_ptr_op(fp_pair_map_get(map, &fp2),OP_EQ, v101); + tt_ptr_op(fp_pair_map_get(map, &fp3),OP_EQ, NULL); fp_pair_map_assert_ok(map);

v = fp_pair_map_remove(map, &fp2); fp_pair_map_assert_ok(map); - tt_ptr_op(v,==, v101); - tt_ptr_op(fp_pair_map_get(map, &fp2),==, NULL); - tt_ptr_op(fp_pair_map_remove(map, &fp2),==, NULL); + tt_ptr_op(v,OP_EQ, v101); + tt_ptr_op(fp_pair_map_get(map, &fp2),OP_EQ, NULL); + tt_ptr_op(fp_pair_map_remove(map, &fp2),OP_EQ, NULL);

fp_pair_map_set(map, &fp2, v101); fp_pair_map_set(map, &fp3, v102); fp_pair_map_set(map, &fp4, v103); - tt_int_op(fp_pair_map_size(map),==, 4); + tt_int_op(fp_pair_map_size(map),OP_EQ, 4); fp_pair_map_assert_ok(map); fp_pair_map_set(map, &fp5, v104); fp_pair_map_set(map, &fp6, v105); @@ -1006,7 +1006,7 @@ test_container_fp_pair_map(void *arg) iter = fp_pair_map_iter_init(map); while (!fp_pair_map_iter_done(iter)) { fp_pair_map_iter_get(iter, &k, &v); - tt_ptr_op(v,==, fp_pair_map_get(map, &k)); + tt_ptr_op(v,OP_EQ, fp_pair_map_get(map, &k));

if (tor_memeq(&fp2, &k, sizeof(fp2))) { iter = fp_pair_map_iter_next_rmv(map, iter); @@ -1016,8 +1016,8 @@ test_container_fp_pair_map(void *arg) }

/* Make sure we removed fp2, but not the others. */ - tt_ptr_op(fp_pair_map_get(map, &fp2),==, NULL); - tt_ptr_op(fp_pair_map_get(map, &fp5),==, v104); + tt_ptr_op(fp_pair_map_get(map, &fp2),OP_EQ, NULL); + tt_ptr_op(fp_pair_map_get(map, &fp5),OP_EQ, v104);

fp_pair_map_assert_ok(map); /* Clean up after ourselves. */ diff --git a/src/test/test_controller_events.c b/src/test/test_controller_events.c index 4d6077b..dd9d590 100644 --- a/src/test/test_controller_events.c +++ b/src/test/test_controller_events.c @@ -22,7 +22,7 @@ help_test_bucket_note_empty(uint32_t expected_msec_since_midnight, tvnow.tv_usec = (msec_since_epoch % 1000) * 1000; connection_buckets_note_empty_ts(&timestamp_var, tokens_before, tokens_removed, &tvnow); - tt_int_op(expected_msec_since_midnight, ==, timestamp_var); + tt_int_op(expected_msec_since_midnight, OP_EQ, timestamp_var);

done: ; @@ -57,20 +57,20 @@ test_cntev_bucket_millis_empty(void *arg) tvnow.tv_usec = 200000;

/* Bucket has not been refilled. */ - tt_int_op(0, ==, bucket_millis_empty(0, 42120, 0, 100, &tvnow)); - tt_int_op(0, ==, bucket_millis_empty(-10, 42120, -10, 100, &tvnow)); + tt_int_op(0, OP_EQ, bucket_millis_empty(0, 42120, 0, 100, &tvnow)); + tt_int_op(0, OP_EQ, bucket_millis_empty(-10, 42120, -10, 100, &tvnow));

/* Bucket was not empty. */ - tt_int_op(0, ==, bucket_millis_empty(10, 42120, 20, 100, &tvnow)); + tt_int_op(0, OP_EQ, bucket_millis_empty(10, 42120, 20, 100, &tvnow));

/* Bucket has been emptied 80 msec ago and has just been refilled. */ - tt_int_op(80, ==, bucket_millis_empty(-20, 42120, -10, 100, &tvnow)); - tt_int_op(80, ==, bucket_millis_empty(-10, 42120, 0, 100, &tvnow)); - tt_int_op(80, ==, bucket_millis_empty(0, 42120, 10, 100, &tvnow)); + tt_int_op(80, OP_EQ, bucket_millis_empty(-20, 42120, -10, 100, &tvnow)); + tt_int_op(80, OP_EQ, bucket_millis_empty(-10, 42120, 0, 100, &tvnow)); + tt_int_op(80, OP_EQ, bucket_millis_empty(0, 42120, 10, 100, &tvnow));

/* Bucket has been emptied 180 msec ago, last refill was 100 msec ago * which was insufficient to make it positive, so cap msec at 100. */ - tt_int_op(100, ==, bucket_millis_empty(0, 42020, 1, 100, &tvnow)); + tt_int_op(100, OP_EQ, bucket_millis_empty(0, 42020, 1, 100, &tvnow));

/* 1970-01-02 00:00:00:050000 */ tvnow.tv_sec = 86400; @@ -78,7 +78,7 @@ test_cntev_bucket_millis_empty(void *arg)

/* Last emptied 30 msec before midnight, tvnow is 50 msec after * midnight, that's 80 msec in total. */ - tt_int_op(80, ==, bucket_millis_empty(0, 86400000 - 30, 1, 100, &tvnow)); + tt_int_op(80, OP_EQ, bucket_millis_empty(0, 86400000 - 30, 1, 100, &tvnow));

done: ; @@ -118,26 +118,26 @@ test_cntev_sum_up_cell_stats(void *arg) cell_stats = tor_malloc_zero(sizeof(cell_stats_t)); add_testing_cell_stats_entry(circ, CELL_RELAY, 0, 0, 0); sum_up_cell_stats_by_command(circ, cell_stats); - tt_u64_op(1, ==, cell_stats->added_cells_appward[CELL_RELAY]); + tt_u64_op(1, OP_EQ, cell_stats->added_cells_appward[CELL_RELAY]);

/* A single RELAY cell was added to the exitward queue. */ add_testing_cell_stats_entry(circ, CELL_RELAY, 0, 0, 1); sum_up_cell_stats_by_command(circ, cell_stats); - tt_u64_op(1, ==, cell_stats->added_cells_exitward[CELL_RELAY]); + tt_u64_op(1, OP_EQ, cell_stats->added_cells_exitward[CELL_RELAY]);

/* A single RELAY cell was removed from the appward queue where it spent * 20 msec. */ add_testing_cell_stats_entry(circ, CELL_RELAY, 2, 1, 0); sum_up_cell_stats_by_command(circ, cell_stats); - tt_u64_op(20, ==, cell_stats->total_time_appward[CELL_RELAY]); - tt_u64_op(1, ==, cell_stats->removed_cells_appward[CELL_RELAY]); + tt_u64_op(20, OP_EQ, cell_stats->total_time_appward[CELL_RELAY]); + tt_u64_op(1, OP_EQ, cell_stats->removed_cells_appward[CELL_RELAY]);

/* A single RELAY cell was removed from the exitward queue where it * spent 30 msec. */ add_testing_cell_stats_entry(circ, CELL_RELAY, 3, 1, 1); sum_up_cell_stats_by_command(circ, cell_stats); - tt_u64_op(30, ==, cell_stats->total_time_exitward[CELL_RELAY]); - tt_u64_op(1, ==, cell_stats->removed_cells_exitward[CELL_RELAY]); + tt_u64_op(30, OP_EQ, cell_stats->total_time_exitward[CELL_RELAY]); + tt_u64_op(1, OP_EQ, cell_stats->removed_cells_exitward[CELL_RELAY]);

done: tor_free(cell_stats); @@ -164,7 +164,7 @@ test_cntev_append_cell_stats(void *arg) append_cell_stats_by_command(event_parts, key, include_if_non_zero, number_to_include); - tt_int_op(0, ==, smartlist_len(event_parts)); + tt_int_op(0, OP_EQ, smartlist_len(event_parts));

/* There's a RELAY cell to include, but the corresponding field in * include_if_non_zero is still zero. */ @@ -172,7 +172,7 @@ test_cntev_append_cell_stats(void *arg) append_cell_stats_by_command(event_parts, key, include_if_non_zero, number_to_include); - tt_int_op(0, ==, smartlist_len(event_parts)); + tt_int_op(0, OP_EQ, smartlist_len(event_parts));

/* Now include single RELAY cell. */ include_if_non_zero[CELL_RELAY] = 2; @@ -180,7 +180,7 @@ test_cntev_append_cell_stats(void *arg) include_if_non_zero, number_to_include); cp = smartlist_pop_last(event_parts); - tt_str_op("Z=relay:1", ==, cp); + tt_str_op("Z=relay:1", OP_EQ, cp); tor_free(cp);

/* Add four CREATE cells. */ @@ -190,7 +190,7 @@ test_cntev_append_cell_stats(void *arg) include_if_non_zero, number_to_include); cp = smartlist_pop_last(event_parts); - tt_str_op("Z=create:4,relay:1", ==, cp); + tt_str_op("Z=create:4,relay:1", OP_EQ, cp);

done: tor_free(cp); @@ -220,14 +220,14 @@ test_cntev_format_cell_stats(void *arg) /* Origin circuit was completely idle. */ cell_stats = tor_malloc_zero(sizeof(cell_stats_t)); format_cell_stats(&event_string, TO_CIRCUIT(ocirc), cell_stats); - tt_str_op("ID=2 OutboundQueue=3 OutboundConn=1", ==, event_string); + tt_str_op("ID=2 OutboundQueue=3 OutboundConn=1", OP_EQ, event_string); tor_free(event_string);

/* Origin circuit had 4 RELAY cells added to its exitward queue. */ cell_stats->added_cells_exitward[CELL_RELAY] = 4; format_cell_stats(&event_string, TO_CIRCUIT(ocirc), cell_stats); tt_str_op("ID=2 OutboundQueue=3 OutboundConn=1 OutboundAdded=relay:4", - ==, event_string); + OP_EQ, event_string); tor_free(event_string);

/* Origin circuit also had 5 CREATE2 cells added to its exitward @@ -235,7 +235,7 @@ test_cntev_format_cell_stats(void *arg) cell_stats->added_cells_exitward[CELL_CREATE2] = 5; format_cell_stats(&event_string, TO_CIRCUIT(ocirc), cell_stats); tt_str_op("ID=2 OutboundQueue=3 OutboundConn=1 OutboundAdded=relay:4," - "create2:5", ==, event_string); + "create2:5", OP_EQ, event_string); tor_free(event_string);

/* Origin circuit also had 7 RELAY cells removed from its exitward queue @@ -245,7 +245,7 @@ test_cntev_format_cell_stats(void *arg) format_cell_stats(&event_string, TO_CIRCUIT(ocirc), cell_stats); tt_str_op("ID=2 OutboundQueue=3 OutboundConn=1 OutboundAdded=relay:4," "create2:5 OutboundRemoved=relay:7 OutboundTime=relay:6", - ==, event_string); + OP_EQ, event_string); tor_free(event_string);

p_chan = tor_malloc_zero(sizeof(channel_tls_t)); @@ -265,14 +265,14 @@ test_cntev_format_cell_stats(void *arg) cell_stats = tor_malloc_zero(sizeof(cell_stats_t)); format_cell_stats(&event_string, TO_CIRCUIT(or_circ), cell_stats); tt_str_op("InboundQueue=8 InboundConn=2 OutboundQueue=9 OutboundConn=1", - ==, event_string); + OP_EQ, event_string); tor_free(event_string);

/* OR circuit had 3 RELAY cells added to its appward queue. */ cell_stats->added_cells_appward[CELL_RELAY] = 3; format_cell_stats(&event_string, TO_CIRCUIT(or_circ), cell_stats); tt_str_op("InboundQueue=8 InboundConn=2 InboundAdded=relay:3 " - "OutboundQueue=9 OutboundConn=1", ==, event_string); + "OutboundQueue=9 OutboundConn=1", OP_EQ, event_string); tor_free(event_string);

/* OR circuit had 7 RELAY cells removed from its appward queue which @@ -282,7 +282,7 @@ test_cntev_format_cell_stats(void *arg) format_cell_stats(&event_string, TO_CIRCUIT(or_circ), cell_stats); tt_str_op("InboundQueue=8 InboundConn=2 InboundAdded=relay:3 " "InboundRemoved=relay:7 InboundTime=relay:6 " - "OutboundQueue=9 OutboundConn=1", ==, event_string); + "OutboundQueue=9 OutboundConn=1", OP_EQ, event_string);

done: tor_free(cell_stats); diff --git a/src/test/test_crypto.c b/src/test/test_crypto.c index 4416134..d3cd013 100644 --- a/src/test/test_crypto.c +++ b/src/test/test_crypto.c @@ -34,24 +34,24 @@ test_crypto_dh(void *arg) ssize_t s1len, s2len;

(void)arg; - tt_int_op(crypto_dh_get_bytes(dh1),==, DH_BYTES); - tt_int_op(crypto_dh_get_bytes(dh2),==, DH_BYTES); + tt_int_op(crypto_dh_get_bytes(dh1),OP_EQ, DH_BYTES); + tt_int_op(crypto_dh_get_bytes(dh2),OP_EQ, DH_BYTES);

memset(p1, 0, DH_BYTES); memset(p2, 0, DH_BYTES); - tt_mem_op(p1,==, p2, DH_BYTES); + tt_mem_op(p1,OP_EQ, p2, DH_BYTES); tt_assert(! crypto_dh_get_public(dh1, p1, DH_BYTES)); - tt_mem_op(p1,!=, p2, DH_BYTES); + tt_mem_op(p1,OP_NE, p2, DH_BYTES); tt_assert(! crypto_dh_get_public(dh2, p2, DH_BYTES)); - tt_mem_op(p1,!=, p2, DH_BYTES); + tt_mem_op(p1,OP_NE, p2, DH_BYTES);

memset(s1, 0, DH_BYTES); memset(s2, 0xFF, DH_BYTES); s1len = crypto_dh_compute_secret(LOG_WARN, dh1, p2, DH_BYTES, s1, 50); s2len = crypto_dh_compute_secret(LOG_WARN, dh2, p1, DH_BYTES, s2, 50); tt_assert(s1len > 0); - tt_int_op(s1len,==, s2len); - tt_mem_op(s1,==, s2, s1len); + tt_int_op(s1len,OP_EQ, s2len); + tt_mem_op(s1,OP_EQ, s2, s1len);

{ /* XXXX Now fabricate some bad values and make sure they get caught, @@ -78,7 +78,7 @@ test_crypto_rng(void *arg) tt_assert(! crypto_seed_rng(0)); crypto_rand(data1, 100); crypto_rand(data2, 100); - tt_mem_op(data1,!=, data2,100); + tt_mem_op(data1,OP_NE, data2,100); allok = 1; for (i = 0; i < 100; ++i) { uint64_t big; @@ -133,15 +133,15 @@ test_crypto_aes(void *arg) memset(data2, 0, 1024); memset(data3, 0, 1024); env1 = crypto_cipher_new(NULL); - tt_ptr_op(env1, !=, NULL); + tt_ptr_op(env1, OP_NE, NULL); env2 = crypto_cipher_new(crypto_cipher_get_key(env1)); - tt_ptr_op(env2, !=, NULL); + tt_ptr_op(env2, OP_NE, NULL);

/* Try encrypting 512 chars. */ crypto_cipher_encrypt(env1, data2, data1, 512); crypto_cipher_decrypt(env2, data3, data2, 512); - tt_mem_op(data1,==, data3, 512); - tt_mem_op(data1,!=, data2, 512); + tt_mem_op(data1,OP_EQ, data3, 512); + tt_mem_op(data1,OP_NE, data2, 512);

/* Now encrypt 1 at a time, and get 1 at a time. */ for (j = 512; j < 560; ++j) { @@ -150,7 +150,7 @@ test_crypto_aes(void *arg) for (j = 512; j < 560; ++j) { crypto_cipher_decrypt(env2, data3+j, data2+j, 1); } - tt_mem_op(data1,==, data3, 560); + tt_mem_op(data1,OP_EQ, data3, 560); /* Now encrypt 3 at a time, and get 5 at a time. */ for (j = 560; j < 1024-5; j += 3) { crypto_cipher_encrypt(env1, data2+j, data1+j, 3); @@ -158,7 +158,7 @@ test_crypto_aes(void *arg) for (j = 560; j < 1024-5; j += 5) { crypto_cipher_decrypt(env2, data3+j, data2+j, 5); } - tt_mem_op(data1,==, data3, 1024-5); + tt_mem_op(data1,OP_EQ, data3, 1024-5); /* Now make sure that when we encrypt with different chunk sizes, we get the same results. */ crypto_cipher_free(env2); @@ -166,7 +166,7 @@ test_crypto_aes(void *arg)

memset(data3, 0, 1024); env2 = crypto_cipher_new(crypto_cipher_get_key(env1)); - tt_ptr_op(env2, !=, NULL); + tt_ptr_op(env2, OP_NE, NULL); for (j = 0; j < 1024-16; j += 17) { crypto_cipher_encrypt(env2, data3+j, data1+j, 17); } @@ -175,7 +175,7 @@ test_crypto_aes(void *arg) printf("%d: %d\t%d\n", j, (int) data2[j], (int) data3[j]); } } - tt_mem_op(data2,==, data3, 1024-16); + tt_mem_op(data2,OP_EQ, data3, 1024-16); crypto_cipher_free(env1); env1 = NULL; crypto_cipher_free(env2); @@ -271,25 +271,25 @@ test_crypto_sha(void *arg) (void)arg; i = crypto_digest(data, "abc", 3); test_memeq_hex(data, "A9993E364706816ABA3E25717850C26C9CD0D89D"); - tt_int_op(i, ==, 0); + tt_int_op(i, OP_EQ, 0);

/* Test SHA-256 with a test vector from the specification. */ i = crypto_digest256(data, "abc", 3, DIGEST_SHA256); test_memeq_hex(data, "BA7816BF8F01CFEA414140DE5DAE2223B00361A3" "96177A9CB410FF61F20015AD"); - tt_int_op(i, ==, 0); + tt_int_op(i, OP_EQ, 0);

/* Test HMAC-SHA256 with test cases from wikipedia and RFC 4231 */

/* Case empty (wikipedia) */ crypto_hmac_sha256(digest, "", 0, "", 0); - tt_str_op(hex_str(digest, 32),==, + tt_str_op(hex_str(digest, 32),OP_EQ, "B613679A0814D9EC772F95D778C35FC5FF1697C493715653C6C712144292C5AD");

/* Case quick-brown (wikipedia) */ crypto_hmac_sha256(digest, "key", 3, "The quick brown fox jumps over the lazy dog", 43); - tt_str_op(hex_str(digest, 32),==, + tt_str_op(hex_str(digest, 32),OP_EQ, "F7BC83F430538424B13298E6AA6FB143EF4D59A14946175997479DBC2D1A3CD8");

/* "Test Case 1" from RFC 4231 */ @@ -357,15 +357,15 @@ test_crypto_sha(void *arg) crypto_digest_add_bytes(d2, "ghijkl", 6); crypto_digest_get_digest(d2, d_out1, sizeof(d_out1)); crypto_digest(d_out2, "abcdefghijkl", 12); - tt_mem_op(d_out1,==, d_out2, DIGEST_LEN); + tt_mem_op(d_out1,OP_EQ, d_out2, DIGEST_LEN); crypto_digest_assign(d2, d1); crypto_digest_add_bytes(d2, "mno", 3); crypto_digest_get_digest(d2, d_out1, sizeof(d_out1)); crypto_digest(d_out2, "abcdefmno", 9); - tt_mem_op(d_out1,==, d_out2, DIGEST_LEN); + tt_mem_op(d_out1,OP_EQ, d_out2, DIGEST_LEN); crypto_digest_get_digest(d1, d_out1, sizeof(d_out1)); crypto_digest(d_out2, "abcdef", 6); - tt_mem_op(d_out1,==, d_out2, DIGEST_LEN); + tt_mem_op(d_out1,OP_EQ, d_out2, DIGEST_LEN); crypto_digest_free(d1); crypto_digest_free(d2);

@@ -378,15 +378,15 @@ test_crypto_sha(void *arg) crypto_digest_add_bytes(d2, "ghijkl", 6); crypto_digest_get_digest(d2, d_out1, sizeof(d_out1)); crypto_digest256(d_out2, "abcdefghijkl", 12, DIGEST_SHA256); - tt_mem_op(d_out1,==, d_out2, DIGEST_LEN); + tt_mem_op(d_out1,OP_EQ, d_out2, DIGEST_LEN); crypto_digest_assign(d2, d1); crypto_digest_add_bytes(d2, "mno", 3); crypto_digest_get_digest(d2, d_out1, sizeof(d_out1)); crypto_digest256(d_out2, "abcdefmno", 9, DIGEST_SHA256); - tt_mem_op(d_out1,==, d_out2, DIGEST_LEN); + tt_mem_op(d_out1,OP_EQ, d_out2, DIGEST_LEN); crypto_digest_get_digest(d1, d_out1, sizeof(d_out1)); crypto_digest256(d_out2, "abcdef", 6, DIGEST_SHA256); - tt_mem_op(d_out1,==, d_out2, DIGEST_LEN); + tt_mem_op(d_out1,OP_EQ, d_out2, DIGEST_LEN);

done: if (d1) @@ -413,42 +413,42 @@ test_crypto_pk(void *arg) tt_assert(pk1 && pk2); tt_assert(! crypto_pk_write_public_key_to_string(pk1, &encoded, &size)); tt_assert(! crypto_pk_read_public_key_from_string(pk2, encoded, size)); - tt_int_op(0,==, crypto_pk_cmp_keys(pk1, pk2)); + tt_int_op(0,OP_EQ, crypto_pk_cmp_keys(pk1, pk2));

/* comparison between keys and NULL */ - tt_int_op(crypto_pk_cmp_keys(NULL, pk1), <, 0); - tt_int_op(crypto_pk_cmp_keys(NULL, NULL), ==, 0); - tt_int_op(crypto_pk_cmp_keys(pk1, NULL), >, 0); + tt_int_op(crypto_pk_cmp_keys(NULL, pk1), OP_LT, 0); + tt_int_op(crypto_pk_cmp_keys(NULL, NULL), OP_EQ, 0); + tt_int_op(crypto_pk_cmp_keys(pk1, NULL), OP_GT, 0);

- tt_int_op(128,==, crypto_pk_keysize(pk1)); - tt_int_op(1024,==, crypto_pk_num_bits(pk1)); - tt_int_op(128,==, crypto_pk_keysize(pk2)); - tt_int_op(1024,==, crypto_pk_num_bits(pk2)); + tt_int_op(128,OP_EQ, crypto_pk_keysize(pk1)); + tt_int_op(1024,OP_EQ, crypto_pk_num_bits(pk1)); + tt_int_op(128,OP_EQ, crypto_pk_keysize(pk2)); + tt_int_op(1024,OP_EQ, crypto_pk_num_bits(pk2));

- tt_int_op(128,==, crypto_pk_public_encrypt(pk2, data1, sizeof(data1), + tt_int_op(128,OP_EQ, crypto_pk_public_encrypt(pk2, data1, sizeof(data1), "Hello whirled.", 15, PK_PKCS1_OAEP_PADDING)); - tt_int_op(128,==, crypto_pk_public_encrypt(pk1, data2, sizeof(data1), + tt_int_op(128,OP_EQ, crypto_pk_public_encrypt(pk1, data2, sizeof(data1), "Hello whirled.", 15, PK_PKCS1_OAEP_PADDING)); /* oaep padding should make encryption not match */ - tt_mem_op(data1,!=, data2, 128); - tt_int_op(15,==, + tt_mem_op(data1,OP_NE, data2, 128); + tt_int_op(15,OP_EQ, crypto_pk_private_decrypt(pk1, data3, sizeof(data3), data1, 128, PK_PKCS1_OAEP_PADDING,1)); - tt_str_op(data3,==, "Hello whirled."); + tt_str_op(data3,OP_EQ, "Hello whirled."); memset(data3, 0, 1024); - tt_int_op(15,==, + tt_int_op(15,OP_EQ, crypto_pk_private_decrypt(pk1, data3, sizeof(data3), data2, 128, PK_PKCS1_OAEP_PADDING,1)); - tt_str_op(data3,==, "Hello whirled."); + tt_str_op(data3,OP_EQ, "Hello whirled."); /* Can't decrypt with public key. */ - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, crypto_pk_private_decrypt(pk2, data3, sizeof(data3), data2, 128, PK_PKCS1_OAEP_PADDING,1)); /* Try again with bad padding */ memcpy(data2+1, "XYZZY", 5); /* This has fails ~ once-in-2^40 */ - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, crypto_pk_private_decrypt(pk1, data3, sizeof(data3), data2, 128, PK_PKCS1_OAEP_PADDING,1));

@@ -464,25 +464,25 @@ test_crypto_pk(void *arg) get_fname("xyzzy")) < 0); tt_assert(! crypto_pk_read_private_key_from_filename(pk2, get_fname("pkey1"))); - tt_int_op(15,==, + tt_int_op(15,OP_EQ, crypto_pk_private_decrypt(pk2, data3, sizeof(data3), data1, 128, PK_PKCS1_OAEP_PADDING,1));

/* Now try signing. */ strlcpy(data1, "Ossifrage", 1024); - tt_int_op(128,==, + tt_int_op(128,OP_EQ, crypto_pk_private_sign(pk1, data2, sizeof(data2), data1, 10)); - tt_int_op(10,==, + tt_int_op(10,OP_EQ, crypto_pk_public_checksig(pk1, data3, sizeof(data3), data2, 128)); - tt_str_op(data3,==, "Ossifrage"); + tt_str_op(data3,OP_EQ, "Ossifrage"); /* Try signing digests. */ - tt_int_op(128,==, crypto_pk_private_sign_digest(pk1, data2, sizeof(data2), + tt_int_op(128,OP_EQ, crypto_pk_private_sign_digest(pk1, data2, sizeof(data2), data1, 10)); - tt_int_op(20,==, + tt_int_op(20,OP_EQ, crypto_pk_public_checksig(pk1, data3, sizeof(data3), data2, 128)); - tt_int_op(0,==, + tt_int_op(0,OP_EQ, crypto_pk_public_checksig_digest(pk1, data1, 10, data2, 128)); - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, crypto_pk_public_checksig_digest(pk1, data1, 11, data2, 128));

/*XXXX test failed signing*/ @@ -491,7 +491,7 @@ test_crypto_pk(void *arg) crypto_pk_free(pk2); pk2 = NULL; i = crypto_pk_asn1_encode(pk1, data1, 1024); - tt_int_op(i, >, 0); + tt_int_op(i, OP_GT, 0); pk2 = crypto_pk_asn1_decode(data1, i); tt_assert(crypto_pk_cmp_keys(pk1,pk2) == 0);

@@ -502,18 +502,18 @@ test_crypto_pk(void *arg) memset(data3,0,1024); len = crypto_pk_public_hybrid_encrypt(pk1,data2,sizeof(data2), data1,i,PK_PKCS1_OAEP_PADDING,0); - tt_int_op(len, >=, 0); + tt_int_op(len, OP_GE, 0); len = crypto_pk_private_hybrid_decrypt(pk1,data3,sizeof(data3), data2,len,PK_PKCS1_OAEP_PADDING,1); - tt_int_op(len,==, i); - tt_mem_op(data1,==, data3,i); + tt_int_op(len,OP_EQ, i); + tt_mem_op(data1,OP_EQ, data3,i); }

/* Try copy_full */ crypto_pk_free(pk2); pk2 = crypto_pk_copy_full(pk1); tt_assert(pk2 != NULL); - tt_ptr_op(pk1, !=, pk2); + tt_ptr_op(pk1, OP_NE, pk2); tt_assert(crypto_pk_cmp_keys(pk1,pk2) == 0);

done: @@ -540,33 +540,33 @@ test_crypto_pk_fingerprints(void *arg) pk = pk_generate(1); tt_assert(pk); n = crypto_pk_asn1_encode(pk, encoded, sizeof(encoded)); - tt_int_op(n, >, 0); - tt_int_op(n, >, 128); - tt_int_op(n, <, 256); + tt_int_op(n, OP_GT, 0); + tt_int_op(n, OP_GT, 128); + tt_int_op(n, OP_LT, 256);

/* Is digest as expected? */ crypto_digest(d, encoded, n); - tt_int_op(0, ==, crypto_pk_get_digest(pk, d2)); - tt_mem_op(d,==, d2, DIGEST_LEN); + tt_int_op(0, OP_EQ, crypto_pk_get_digest(pk, d2)); + tt_mem_op(d,OP_EQ, d2, DIGEST_LEN);

/* Is fingerprint right? */ - tt_int_op(0, ==, crypto_pk_get_fingerprint(pk, fingerprint, 0)); - tt_int_op(strlen(fingerprint), ==, DIGEST_LEN * 2); + tt_int_op(0, OP_EQ, crypto_pk_get_fingerprint(pk, fingerprint, 0)); + tt_int_op(strlen(fingerprint), OP_EQ, DIGEST_LEN * 2); test_memeq_hex(d, fingerprint);

/* Are spaces right? */ - tt_int_op(0, ==, crypto_pk_get_fingerprint(pk, fingerprint, 1)); + tt_int_op(0, OP_EQ, crypto_pk_get_fingerprint(pk, fingerprint, 1)); for (i = 4; i < strlen(fingerprint); i += 5) { - tt_int_op(fingerprint[i], ==, ' '); + tt_int_op(fingerprint[i], OP_EQ, ' '); } tor_strstrip(fingerprint, " "); - tt_int_op(strlen(fingerprint), ==, DIGEST_LEN * 2); + tt_int_op(strlen(fingerprint), OP_EQ, DIGEST_LEN * 2); test_memeq_hex(d, fingerprint);

/* Now hash again and check crypto_pk_get_hashed_fingerprint. */ crypto_digest(d2, d, sizeof(d)); - tt_int_op(0, ==, crypto_pk_get_hashed_fingerprint(pk, fingerprint)); - tt_int_op(strlen(fingerprint), ==, DIGEST_LEN * 2); + tt_int_op(0, OP_EQ, crypto_pk_get_hashed_fingerprint(pk, fingerprint)); + tt_int_op(strlen(fingerprint), OP_EQ, DIGEST_LEN * 2); test_memeq_hex(d2, fingerprint);

done: @@ -591,14 +591,14 @@ test_crypto_digests(void *arg)

r = crypto_pk_get_digest(k, digest); tt_assert(r == 0); - tt_mem_op(hex_str(digest, DIGEST_LEN),==, + tt_mem_op(hex_str(digest, DIGEST_LEN),OP_EQ, AUTHORITY_SIGNKEY_A_DIGEST, HEX_DIGEST_LEN);

r = crypto_pk_get_all_digests(k, &pkey_digests);

- tt_mem_op(hex_str(pkey_digests.d[DIGEST_SHA1], DIGEST_LEN),==, + tt_mem_op(hex_str(pkey_digests.d[DIGEST_SHA1], DIGEST_LEN),OP_EQ, AUTHORITY_SIGNKEY_A_DIGEST, HEX_DIGEST_LEN); - tt_mem_op(hex_str(pkey_digests.d[DIGEST_SHA256], DIGEST256_LEN),==, + tt_mem_op(hex_str(pkey_digests.d[DIGEST_SHA256], DIGEST256_LEN),OP_EQ, AUTHORITY_SIGNKEY_A_DIGEST256, HEX_DIGEST256_LEN); done: crypto_pk_free(k); @@ -622,31 +622,31 @@ test_crypto_formats(void *arg) memset(data1, 6, 1024); for (idx = 0; idx < 10; ++idx) { i = base64_encode(data2, 1024, data1, idx); - tt_int_op(i, >=, 0); + tt_int_op(i, OP_GE, 0); j = base64_decode(data3, 1024, data2, i); - tt_int_op(j,==, idx); - tt_mem_op(data3,==, data1, idx); + tt_int_op(j,OP_EQ, idx); + tt_mem_op(data3,OP_EQ, data1, idx); }

strlcpy(data1, "Test string that contains 35 chars.", 1024); strlcat(data1, " 2nd string that contains 35 chars.", 1024);

i = base64_encode(data2, 1024, data1, 71); - tt_int_op(i, >=, 0); + tt_int_op(i, OP_GE, 0); j = base64_decode(data3, 1024, data2, i); - tt_int_op(j,==, 71); - tt_str_op(data3,==, data1); - tt_int_op(data2[i], ==, '\0'); + tt_int_op(j,OP_EQ, 71); + tt_str_op(data3,OP_EQ, data1); + tt_int_op(data2[i], OP_EQ, '\0');

crypto_rand(data1, DIGEST_LEN); memset(data2, 100, 1024); digest_to_base64(data2, data1); - tt_int_op(BASE64_DIGEST_LEN,==, strlen(data2)); - tt_int_op(100,==, data2[BASE64_DIGEST_LEN+2]); + tt_int_op(BASE64_DIGEST_LEN,OP_EQ, strlen(data2)); + tt_int_op(100,OP_EQ, data2[BASE64_DIGEST_LEN+2]); memset(data3, 99, 1024); - tt_int_op(digest_from_base64(data3, data2),==, 0); - tt_mem_op(data1,==, data3, DIGEST_LEN); - tt_int_op(99,==, data3[DIGEST_LEN+1]); + tt_int_op(digest_from_base64(data3, data2),OP_EQ, 0); + tt_mem_op(data1,OP_EQ, data3, DIGEST_LEN); + tt_int_op(99,OP_EQ, data3[DIGEST_LEN+1]);

tt_assert(digest_from_base64(data3, "###") < 0);

@@ -654,12 +654,12 @@ test_crypto_formats(void *arg) crypto_rand(data2, DIGEST256_LEN); memset(data2, 100, 1024); digest256_to_base64(data2, data1); - tt_int_op(BASE64_DIGEST256_LEN,==, strlen(data2)); - tt_int_op(100,==, data2[BASE64_DIGEST256_LEN+2]); + tt_int_op(BASE64_DIGEST256_LEN,OP_EQ, strlen(data2)); + tt_int_op(100,OP_EQ, data2[BASE64_DIGEST256_LEN+2]); memset(data3, 99, 1024); - tt_int_op(digest256_from_base64(data3, data2),==, 0); - tt_mem_op(data1,==, data3, DIGEST256_LEN); - tt_int_op(99,==, data3[DIGEST256_LEN+1]); + tt_int_op(digest256_from_base64(data3, data2),OP_EQ, 0); + tt_mem_op(data1,OP_EQ, data3, DIGEST256_LEN); + tt_int_op(99,OP_EQ, data3[DIGEST256_LEN+1]);

/* Base32 tests */ strlcpy(data1, "5chrs", 1024); @@ -668,27 +668,27 @@ test_crypto_formats(void *arg) * By 5s: [00110 10101 10001 10110 10000 11100 10011 10011] */ base32_encode(data2, 9, data1, 5); - tt_str_op(data2,==, "gvrwq4tt"); + tt_str_op(data2,OP_EQ, "gvrwq4tt");

strlcpy(data1, "\xFF\xF5\x6D\x44\xAE\x0D\x5C\xC9\x62\xC4", 1024); base32_encode(data2, 30, data1, 10); - tt_str_op(data2,==, "772w2rfobvomsywe"); + tt_str_op(data2,OP_EQ, "772w2rfobvomsywe");

/* Base16 tests */ strlcpy(data1, "6chrs\xff", 1024); base16_encode(data2, 13, data1, 6); - tt_str_op(data2,==, "3663687273FF"); + tt_str_op(data2,OP_EQ, "3663687273FF");

strlcpy(data1, "f0d678affc000100", 1024); i = base16_decode(data2, 8, data1, 16); - tt_int_op(i,==, 0); - tt_mem_op(data2,==, "\xf0\xd6\x78\xaf\xfc\x00\x01\x00",8); + tt_int_op(i,OP_EQ, 0); + tt_mem_op(data2,OP_EQ, "\xf0\xd6\x78\xaf\xfc\x00\x01\x00",8);

/* now try some failing base16 decodes */ - tt_int_op(-1,==, base16_decode(data2, 8, data1, 15)); /* odd input len */ - tt_int_op(-1,==, base16_decode(data2, 7, data1, 16)); /* dest too short */ + tt_int_op(-1,OP_EQ, base16_decode(data2, 8, data1, 15)); /* odd input len */ + tt_int_op(-1,OP_EQ, base16_decode(data2, 7, data1, 16)); /* dest too short */ strlcpy(data1, "f0dz!8affc000100", 1024); - tt_int_op(-1,==, base16_decode(data2, 8, data1, 16)); + tt_int_op(-1,OP_EQ, base16_decode(data2, 8, data1, 16));

tor_free(data1); tor_free(data2); @@ -697,10 +697,10 @@ test_crypto_formats(void *arg) /* Add spaces to fingerprint */ { data1 = tor_strdup("ABCD1234ABCD56780000ABCD1234ABCD56780000"); - tt_int_op(strlen(data1),==, 40); + tt_int_op(strlen(data1),OP_EQ, 40); data2 = tor_malloc(FINGERPRINT_LEN+1); crypto_add_spaces_to_fp(data2, FINGERPRINT_LEN+1, data1); - tt_str_op(data2,==, "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 0000"); + tt_str_op(data2,OP_EQ, "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 0000"); tor_free(data1); tor_free(data2); } @@ -728,7 +728,7 @@ test_crypto_s2k_rfc2440(void *arg)

secret_to_key_rfc2440(buf+9, 20, "", 0, buf); crypto_digest(buf2+9, buf3, 1024); - tt_mem_op(buf,==, buf2, 29); + tt_mem_op(buf,OP_EQ, buf2, 29);

memcpy(buf,"vrbacrda",8); memcpy(buf2,"vrbacrda",8); @@ -739,7 +739,7 @@ test_crypto_s2k_rfc2440(void *arg) memcpy(buf3+i, "vrbacrda12345678", 16); } crypto_digest(buf2+9, buf3, 65536); - tt_mem_op(buf,==, buf2, 29); + tt_mem_op(buf,OP_EQ, buf2, 29);

done: tor_free(buf3); @@ -757,10 +757,10 @@ run_s2k_tests(const unsigned flags, const unsigned type,

r = secret_to_key_new(buf, sizeof(buf), &sz, pw1, strlen(pw1), flags); - tt_int_op(r, ==, S2K_OKAY); - tt_int_op(buf[0], ==, type); + tt_int_op(r, OP_EQ, S2K_OKAY); + tt_int_op(buf[0], OP_EQ, type);

- tt_int_op(sz, ==, keylen + speclen); + tt_int_op(sz, OP_EQ, keylen + speclen);

if (legacy) { memmove(buf, buf+1, sz-1); @@ -768,10 +768,10 @@ run_s2k_tests(const unsigned flags, const unsigned type, --speclen; }

- tt_int_op(S2K_OKAY, ==, + tt_int_op(S2K_OKAY, OP_EQ, secret_to_key_check(buf, sz, pw1, strlen(pw1)));

- tt_int_op(S2K_BAD_SECRET, ==, + tt_int_op(S2K_BAD_SECRET, OP_EQ, secret_to_key_check(buf, sz, pw2, strlen(pw2)));

/* Move key to buf2, and clear it. */ @@ -780,24 +780,24 @@ run_s2k_tests(const unsigned flags, const unsigned type, memset(buf+speclen, 0, sz - speclen);

/* Derivekey should produce the same results. */ - tt_int_op(S2K_OKAY, ==, + tt_int_op(S2K_OKAY, OP_EQ, secret_to_key_derivekey(buf3, keylen, buf, speclen, pw1, strlen(pw1)));

- tt_mem_op(buf2, ==, buf3, keylen); + tt_mem_op(buf2, OP_EQ, buf3, keylen);

/* Derivekey with a longer output should fill the output. */ memset(buf2, 0, sizeof(buf2)); - tt_int_op(S2K_OKAY, ==, + tt_int_op(S2K_OKAY, OP_EQ, secret_to_key_derivekey(buf2, sizeof(buf2), buf, speclen, pw1, strlen(pw1)));

- tt_mem_op(buf2, !=, buf3, sizeof(buf2)); + tt_mem_op(buf2, OP_NE, buf3, sizeof(buf2));

memset(buf3, 0, sizeof(buf3)); - tt_int_op(S2K_OKAY, ==, + tt_int_op(S2K_OKAY, OP_EQ, secret_to_key_derivekey(buf3, sizeof(buf3), buf, speclen, pw1, strlen(pw1))); - tt_mem_op(buf2, ==, buf3, sizeof(buf3)); + tt_mem_op(buf2, OP_EQ, buf3, sizeof(buf3)); tt_assert(!tor_mem_is_zero((char*)buf2+keylen, sizeof(buf2)-keylen));

done: @@ -833,50 +833,50 @@ test_crypto_s2k_errors(void *arg) (void)arg;

/* Bogus specifiers: simple */ - tt_int_op(S2K_BAD_LEN, ==, + tt_int_op(S2K_BAD_LEN, OP_EQ, secret_to_key_derivekey(buf, sizeof(buf), (const uint8_t*)"", 0, "ABC", 3)); - tt_int_op(S2K_BAD_ALGORITHM, ==, + tt_int_op(S2K_BAD_ALGORITHM, OP_EQ, secret_to_key_derivekey(buf, sizeof(buf), (const uint8_t*)"\x10", 1, "ABC", 3)); - tt_int_op(S2K_BAD_LEN, ==, + tt_int_op(S2K_BAD_LEN, OP_EQ, secret_to_key_derivekey(buf, sizeof(buf), (const uint8_t*)"\x01\x02", 2, "ABC", 3));

- tt_int_op(S2K_BAD_LEN, ==, + tt_int_op(S2K_BAD_LEN, OP_EQ, secret_to_key_check((const uint8_t*)"", 0, "ABC", 3)); - tt_int_op(S2K_BAD_ALGORITHM, ==, + tt_int_op(S2K_BAD_ALGORITHM, OP_EQ, secret_to_key_check((const uint8_t*)"\x10", 1, "ABC", 3)); - tt_int_op(S2K_BAD_LEN, ==, + tt_int_op(S2K_BAD_LEN, OP_EQ, secret_to_key_check((const uint8_t*)"\x01\x02", 2, "ABC", 3));

/* too long gets "BAD_LEN" too */ memset(buf, 0, sizeof(buf)); buf[0] = 2; - tt_int_op(S2K_BAD_LEN, ==, + tt_int_op(S2K_BAD_LEN, OP_EQ, secret_to_key_derivekey(buf2, sizeof(buf2), buf, sizeof(buf), "ABC", 3));

/* Truncated output */ #ifdef HAVE_LIBSCRYPT_H - tt_int_op(S2K_TRUNCATED, ==, secret_to_key_new(buf, 50, &sz, + tt_int_op(S2K_TRUNCATED, OP_EQ, secret_to_key_new(buf, 50, &sz, "ABC", 3, 0)); - tt_int_op(S2K_TRUNCATED, ==, secret_to_key_new(buf, 50, &sz, + tt_int_op(S2K_TRUNCATED, OP_EQ, secret_to_key_new(buf, 50, &sz, "ABC", 3, S2K_FLAG_LOW_MEM)); #endif - tt_int_op(S2K_TRUNCATED, ==, secret_to_key_new(buf, 37, &sz, + tt_int_op(S2K_TRUNCATED, OP_EQ, secret_to_key_new(buf, 37, &sz, "ABC", 3, S2K_FLAG_USE_PBKDF2)); - tt_int_op(S2K_TRUNCATED, ==, secret_to_key_new(buf, 29, &sz, + tt_int_op(S2K_TRUNCATED, OP_EQ, secret_to_key_new(buf, 29, &sz, "ABC", 3, S2K_FLAG_NO_SCRYPT));

#ifdef HAVE_LIBSCRYPT_H - tt_int_op(S2K_TRUNCATED, ==, secret_to_key_make_specifier(buf, 18, 0)); - tt_int_op(S2K_TRUNCATED, ==, secret_to_key_make_specifier(buf, 18, + tt_int_op(S2K_TRUNCATED, OP_EQ, secret_to_key_make_specifier(buf, 18, 0)); + tt_int_op(S2K_TRUNCATED, OP_EQ, secret_to_key_make_specifier(buf, 18, S2K_FLAG_LOW_MEM)); #endif - tt_int_op(S2K_TRUNCATED, ==, secret_to_key_make_specifier(buf, 17, + tt_int_op(S2K_TRUNCATED, OP_EQ, secret_to_key_make_specifier(buf, 17, S2K_FLAG_USE_PBKDF2)); - tt_int_op(S2K_TRUNCATED, ==, secret_to_key_make_specifier(buf, 9, + tt_int_op(S2K_TRUNCATED, OP_EQ, secret_to_key_make_specifier(buf, 9, S2K_FLAG_NO_SCRYPT));

/* Now try using type-specific bogus specifiers. */ @@ -886,7 +886,7 @@ test_crypto_s2k_errors(void *arg) memset(buf, 0, sizeof(buf)); buf[0] = 1; /* pbkdf2 */ buf[17] = 100; /* 1<<100 is much bigger than INT32_MAX */ - tt_int_op(S2K_BAD_PARAMS, ==, + tt_int_op(S2K_BAD_PARAMS, OP_EQ, secret_to_key_derivekey(buf2, sizeof(buf2), buf, 18, "ABC", 3));

@@ -895,7 +895,7 @@ test_crypto_s2k_errors(void *arg) memset(buf, 0, sizeof(buf)); buf[0] = 2; /* scrypt */ buf[17] = 100; /* 1<<100 is much bigger than UINT64_MAX */ - tt_int_op(S2K_BAD_PARAMS, ==, + tt_int_op(S2K_BAD_PARAMS, OP_EQ, secret_to_key_derivekey(buf2, sizeof(buf2), buf, 19, "ABC", 3)); #endif @@ -926,7 +926,7 @@ test_crypto_scrypt_vectors(void *arg) base16_decode((char*)spec, sizeof(spec), "0400", 4); memset(out, 0x00, sizeof(out)); - tt_int_op(64, ==, + tt_int_op(64, OP_EQ, secret_to_key_compute_key(out, 64, spec, 2, "", 0, 2)); test_memeq_hex(out, "77d6576238657b203b19ca42c18a0497" @@ -937,7 +937,7 @@ test_crypto_scrypt_vectors(void *arg) base16_decode((char*)spec, sizeof(spec), "4e61436c" "0A34", 12); memset(out, 0x00, sizeof(out)); - tt_int_op(64, ==, + tt_int_op(64, OP_EQ, secret_to_key_compute_key(out, 64, spec, 6, "password", 8, 2)); test_memeq_hex(out, "fdbabe1c9d3472007856e7190d01e9fe" @@ -948,7 +948,7 @@ test_crypto_scrypt_vectors(void *arg) base16_decode((char*)spec, sizeof(spec), "536f6469756d43686c6f72696465" "0e30", 32); memset(out, 0x00, sizeof(out)); - tt_int_op(64, ==, + tt_int_op(64, OP_EQ, secret_to_key_compute_key(out, 64, spec, 16, "pleaseletmein", 13, 2)); test_memeq_hex(out, @@ -960,7 +960,7 @@ test_crypto_scrypt_vectors(void *arg) base16_decode((char*)spec, sizeof(spec), "536f6469756d43686c6f72696465" "1430", 32); memset(out, 0x00, sizeof(out)); - tt_int_op(64, ==, + tt_int_op(64, OP_EQ, secret_to_key_compute_key(out, 64, spec, 16, "pleaseletmein", 13, 2)); test_memeq_hex(out, @@ -984,28 +984,28 @@ test_crypto_pbkdf2_vectors(void *arg) base16_decode((char*)spec, sizeof(spec), "73616c74" "00" , 10); memset(out, 0x00, sizeof(out)); - tt_int_op(20, ==, + tt_int_op(20, OP_EQ, secret_to_key_compute_key(out, 20, spec, 5, "password", 8, 1)); test_memeq_hex(out, "0c60c80f961f0e71f3a9b524af6012062fe037a6");

base16_decode((char*)spec, sizeof(spec), "73616c74" "01" , 10); memset(out, 0x00, sizeof(out)); - tt_int_op(20, ==, + tt_int_op(20, OP_EQ, secret_to_key_compute_key(out, 20, spec, 5, "password", 8, 1)); test_memeq_hex(out, "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957");

base16_decode((char*)spec, sizeof(spec), "73616c74" "0C" , 10); memset(out, 0x00, sizeof(out)); - tt_int_op(20, ==, + tt_int_op(20, OP_EQ, secret_to_key_compute_key(out, 20, spec, 5, "password", 8, 1)); test_memeq_hex(out, "4b007901b765489abead49d926f721d065a429c1");

base16_decode((char*)spec, sizeof(spec), "73616c74" "18" , 10); memset(out, 0x00, sizeof(out)); - tt_int_op(20, ==, + tt_int_op(20, OP_EQ, secret_to_key_compute_key(out, 20, spec, 5, "password", 8, 1)); test_memeq_hex(out, "eefe3d61cd4da4e4e9945b3d6ba2158c2634e984");

@@ -1013,7 +1013,7 @@ test_crypto_pbkdf2_vectors(void *arg) "73616c7453414c5473616c7453414c5473616c745" "3414c5473616c7453414c5473616c74" "0C" , 74); memset(out, 0x00, sizeof(out)); - tt_int_op(25, ==, + tt_int_op(25, OP_EQ, secret_to_key_compute_key(out, 25, spec, 37, "passwordPASSWORDpassword", 24, 1)); test_memeq_hex(out, "3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038"); @@ -1021,7 +1021,7 @@ test_crypto_pbkdf2_vectors(void *arg) base16_decode((char*)spec, sizeof(spec), "7361006c74" "0c" , 12); memset(out, 0x00, sizeof(out)); - tt_int_op(16, ==, + tt_int_op(16, OP_EQ, secret_to_key_compute_key(out, 16, spec, 6, "pass\0word", 9, 1)); test_memeq_hex(out, "56fa6aa75548099dcc37d7f03425e0c3");

@@ -1049,30 +1049,30 @@ test_crypto_pwbox(void *arg) (void)arg;

for (i = 0; i < ARRAY_LENGTH(flags); ++i) { - tt_int_op(0, ==, crypto_pwbox(&boxed, &len, + tt_int_op(0, OP_EQ, crypto_pwbox(&boxed, &len, (const uint8_t*)msg, strlen(msg), pw, strlen(pw), flags[i])); tt_assert(boxed); tt_assert(len > 128+32);

- tt_int_op(0, ==, crypto_unpwbox(&decoded, &dlen, boxed, len, + tt_int_op(0, OP_EQ, crypto_unpwbox(&decoded, &dlen, boxed, len, pw, strlen(pw)));

tt_assert(decoded); - tt_uint_op(dlen, ==, strlen(msg)); - tt_mem_op(decoded, ==, msg, dlen); + tt_uint_op(dlen, OP_EQ, strlen(msg)); + tt_mem_op(decoded, OP_EQ, msg, dlen);

tor_free(decoded);

- tt_int_op(UNPWBOX_BAD_SECRET, ==, crypto_unpwbox(&decoded, &dlen, + tt_int_op(UNPWBOX_BAD_SECRET, OP_EQ, crypto_unpwbox(&decoded, &dlen, boxed, len, pw, strlen(pw)-1)); boxed[len-1] ^= 1; - tt_int_op(UNPWBOX_BAD_SECRET, ==, crypto_unpwbox(&decoded, &dlen, + tt_int_op(UNPWBOX_BAD_SECRET, OP_EQ, crypto_unpwbox(&decoded, &dlen, boxed, len, pw, strlen(pw))); boxed[0] = 255; - tt_int_op(UNPWBOX_CORRUPTED, ==, crypto_unpwbox(&decoded, &dlen, + tt_int_op(UNPWBOX_CORRUPTED, OP_EQ, crypto_unpwbox(&decoded, &dlen, boxed, len, pw, strlen(pw)));

@@ -1114,79 +1114,79 @@ test_crypto_aes_iv(void *arg) encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted1, 16 + 4095, plain, 4095);

- tt_int_op(encrypted_size,==, 16 + 4095); + tt_int_op(encrypted_size,OP_EQ, 16 + 4095); tt_assert(encrypted_size > 0); /* This is obviously true, since 4111 is * greater than 0, but its truth is not * obvious to all analysis tools. */ decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 4095, encrypted1, encrypted_size);

- tt_int_op(decrypted_size,==, 4095); + tt_int_op(decrypted_size,OP_EQ, 4095); tt_assert(decrypted_size > 0); - tt_mem_op(plain,==, decrypted1, 4095); + tt_mem_op(plain,OP_EQ, decrypted1, 4095); /* Encrypt a second time (with a new random initialization vector). */ encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted2, 16 + 4095, plain, 4095);

- tt_int_op(encrypted_size,==, 16 + 4095); + tt_int_op(encrypted_size,OP_EQ, 16 + 4095); tt_assert(encrypted_size > 0); decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted2, 4095, encrypted2, encrypted_size); - tt_int_op(decrypted_size,==, 4095); + tt_int_op(decrypted_size,OP_EQ, 4095); tt_assert(decrypted_size > 0); - tt_mem_op(plain,==, decrypted2, 4095); - tt_mem_op(encrypted1,!=, encrypted2, encrypted_size); + tt_mem_op(plain,OP_EQ, decrypted2, 4095); + tt_mem_op(encrypted1,OP_NE, encrypted2, encrypted_size); /* Decrypt with the wrong key. */ decrypted_size = crypto_cipher_decrypt_with_iv(key2, decrypted2, 4095, encrypted1, encrypted_size); - tt_int_op(decrypted_size,==, 4095); - tt_mem_op(plain,!=, decrypted2, decrypted_size); + tt_int_op(decrypted_size,OP_EQ, 4095); + tt_mem_op(plain,OP_NE, decrypted2, decrypted_size); /* Alter the initialization vector. */ encrypted1[0] += 42; decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 4095, encrypted1, encrypted_size); - tt_int_op(decrypted_size,==, 4095); - tt_mem_op(plain,!=, decrypted2, 4095); + tt_int_op(decrypted_size,OP_EQ, 4095); + tt_mem_op(plain,OP_NE, decrypted2, 4095); /* Special length case: 1. */ encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted1, 16 + 1, plain_1, 1); - tt_int_op(encrypted_size,==, 16 + 1); + tt_int_op(encrypted_size,OP_EQ, 16 + 1); tt_assert(encrypted_size > 0); decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 1, encrypted1, encrypted_size); - tt_int_op(decrypted_size,==, 1); + tt_int_op(decrypted_size,OP_EQ, 1); tt_assert(decrypted_size > 0); - tt_mem_op(plain_1,==, decrypted1, 1); + tt_mem_op(plain_1,OP_EQ, decrypted1, 1); /* Special length case: 15. */ encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted1, 16 + 15, plain_15, 15); - tt_int_op(encrypted_size,==, 16 + 15); + tt_int_op(encrypted_size,OP_EQ, 16 + 15); tt_assert(encrypted_size > 0); decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 15, encrypted1, encrypted_size); - tt_int_op(decrypted_size,==, 15); + tt_int_op(decrypted_size,OP_EQ, 15); tt_assert(decrypted_size > 0); - tt_mem_op(plain_15,==, decrypted1, 15); + tt_mem_op(plain_15,OP_EQ, decrypted1, 15); /* Special length case: 16. */ encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted1, 16 + 16, plain_16, 16); - tt_int_op(encrypted_size,==, 16 + 16); + tt_int_op(encrypted_size,OP_EQ, 16 + 16); tt_assert(encrypted_size > 0); decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 16, encrypted1, encrypted_size); - tt_int_op(decrypted_size,==, 16); + tt_int_op(decrypted_size,OP_EQ, 16); tt_assert(decrypted_size > 0); - tt_mem_op(plain_16,==, decrypted1, 16); + tt_mem_op(plain_16,OP_EQ, decrypted1, 16); /* Special length case: 17. */ encrypted_size = crypto_cipher_encrypt_with_iv(key1, encrypted1, 16 + 17, plain_17, 17); - tt_int_op(encrypted_size,==, 16 + 17); + tt_int_op(encrypted_size,OP_EQ, 16 + 17); tt_assert(encrypted_size > 0); decrypted_size = crypto_cipher_decrypt_with_iv(key1, decrypted1, 17, encrypted1, encrypted_size); - tt_int_op(decrypted_size,==, 17); + tt_int_op(decrypted_size,OP_EQ, 17); tt_assert(decrypted_size > 0); - tt_mem_op(plain_17,==, decrypted1, 17); + tt_mem_op(plain_17,OP_EQ, decrypted1, 17);

done: /* Free memory. */ @@ -1208,26 +1208,26 @@ test_crypto_base32_decode(void *arg) /* Encode and decode a random string. */ base32_encode(encoded, 96 + 1, plain, 60); res = base32_decode(decoded, 60, encoded, 96); - tt_int_op(res,==, 0); - tt_mem_op(plain,==, decoded, 60); + tt_int_op(res,OP_EQ, 0); + tt_mem_op(plain,OP_EQ, decoded, 60); /* Encode, uppercase, and decode a random string. */ base32_encode(encoded, 96 + 1, plain, 60); tor_strupper(encoded); res = base32_decode(decoded, 60, encoded, 96); - tt_int_op(res,==, 0); - tt_mem_op(plain,==, decoded, 60); + tt_int_op(res,OP_EQ, 0); + tt_mem_op(plain,OP_EQ, decoded, 60); /* Change encoded string and decode. */ if (encoded[0] == 'A' || encoded[0] == 'a') encoded[0] = 'B'; else encoded[0] = 'A'; res = base32_decode(decoded, 60, encoded, 96); - tt_int_op(res,==, 0); - tt_mem_op(plain,!=, decoded, 60); + tt_int_op(res,OP_EQ, 0); + tt_mem_op(plain,OP_NE, decoded, 60); /* Bad encodings. */ encoded[0] = '!'; res = base32_decode(decoded, 60, encoded, 96); - tt_int_op(0, >, res); + tt_int_op(0, OP_GT, res);

done: ; @@ -1250,7 +1250,7 @@ test_crypto_kdf_TAP(void *arg) * your own. */ memset(key_material, 0, sizeof(key_material)); EXPAND(""); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); test_memeq_hex(key_material, "5ba93c9db0cff93f52b521d7420e43f6eda2784fbf8b4530d8" "d246dd74ac53a13471bba17941dff7c4ea21bb365bbeeaf5f2" @@ -1258,7 +1258,7 @@ test_crypto_kdf_TAP(void *arg) "f07b01e13da42c6cf1de3abfdea9b95f34687cbbe92b9a7383");

EXPAND("Tor"); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); test_memeq_hex(key_material, "776c6214fc647aaa5f683c737ee66ec44f03d0372e1cce6922" "7950f236ddf1e329a7ce7c227903303f525a8c6662426e8034" @@ -1266,7 +1266,7 @@ test_crypto_kdf_TAP(void *arg) "3f45dfda1a80bdc8b80de01b23e3e0ffae099b3e4ccf28dc28");

EXPAND("AN ALARMING ITEM TO FIND ON A MONTHLY AUTO-DEBIT NOTICE"); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); test_memeq_hex(key_material, "a340b5d126086c3ab29c2af4179196dbf95e1c72431419d331" "4844bf8f6afb6098db952b95581fb6c33625709d6f4400b8e7" @@ -1302,7 +1302,7 @@ test_crypto_hkdf_sha256(void *arg) /* Test vectors generated with ntor_ref.py */ memset(key_material, 0, sizeof(key_material)); EXPAND(""); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); test_memeq_hex(key_material, "d3490ed48b12a48f9547861583573fe3f19aafe3f81dc7fc75" "eeed96d741b3290f941576c1f9f0b2d463d1ec7ab2c6bf71cd" @@ -1310,7 +1310,7 @@ test_crypto_hkdf_sha256(void *arg) "dcf6abe0d20c77cf363e8ffe358927817a3d3e73712cee28d8");

EXPAND("Tor"); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); test_memeq_hex(key_material, "5521492a85139a8d9107a2d5c0d9c91610d0f95989975ebee6" "c02a4f8d622a6cfdf9b7c7edd3832e2760ded1eac309b76f8d" @@ -1318,7 +1318,7 @@ test_crypto_hkdf_sha256(void *arg) "961be9fdb9f93197ea8e5977180801926d3321fa21513e59ac");

EXPAND("AN ALARMING ITEM TO FIND ON YOUR CREDIT-RATING STATEMENT"); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); test_memeq_hex(key_material, "a2aa9b50da7e481d30463adb8f233ff06e9571a0ca6ab6df0f" "b206fa34e5bc78d063fc291501beec53b36e5a0e434561200c" @@ -1381,7 +1381,7 @@ test_crypto_curve25519_impl(void *arg) e2k[31] |= (byte & 0x80); } curve25519_impl(e1e2k,e1,e2k); - tt_mem_op(e1e2k,==, e2e1k, 32); + tt_mem_op(e1e2k,OP_EQ, e2e1k, 32); if (loop == loop_max-1) { break; } @@ -1417,7 +1417,7 @@ test_crypto_curve25519_wrappers(void *arg) tt_assert(curve25519_public_key_is_ok(&pubkey2)); curve25519_handshake(output1, &seckey1, &pubkey2); curve25519_handshake(output2, &seckey2, &pubkey1); - tt_mem_op(output1,==, output2, sizeof(output1)); + tt_mem_op(output1,OP_EQ, output2, sizeof(output1));

done: ; @@ -1434,26 +1434,26 @@ test_crypto_curve25519_encode(void *arg)

curve25519_secret_key_generate(&seckey, 0); curve25519_public_key_generate(&key1, &seckey); - tt_int_op(0, ==, curve25519_public_to_base64(buf, &key1)); - tt_int_op(CURVE25519_BASE64_PADDED_LEN, ==, strlen(buf)); + tt_int_op(0, OP_EQ, curve25519_public_to_base64(buf, &key1)); + tt_int_op(CURVE25519_BASE64_PADDED_LEN, OP_EQ, strlen(buf));

- tt_int_op(0, ==, curve25519_public_from_base64(&key2, buf)); - tt_mem_op(key1.public_key,==, key2.public_key, CURVE25519_PUBKEY_LEN); + tt_int_op(0, OP_EQ, curve25519_public_from_base64(&key2, buf)); + tt_mem_op(key1.public_key,OP_EQ, key2.public_key, CURVE25519_PUBKEY_LEN);

buf[CURVE25519_BASE64_PADDED_LEN - 1] = '\0'; - tt_int_op(CURVE25519_BASE64_PADDED_LEN-1, ==, strlen(buf)); - tt_int_op(0, ==, curve25519_public_from_base64(&key3, buf)); - tt_mem_op(key1.public_key,==, key3.public_key, CURVE25519_PUBKEY_LEN); + tt_int_op(CURVE25519_BASE64_PADDED_LEN-1, OP_EQ, strlen(buf)); + tt_int_op(0, OP_EQ, curve25519_public_from_base64(&key3, buf)); + tt_mem_op(key1.public_key,OP_EQ, key3.public_key, CURVE25519_PUBKEY_LEN);

/* Now try bogus parses. */ strlcpy(buf, "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$=", sizeof(buf)); - tt_int_op(-1, ==, curve25519_public_from_base64(&key3, buf)); + tt_int_op(-1, OP_EQ, curve25519_public_from_base64(&key3, buf));

strlcpy(buf, "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$", sizeof(buf)); - tt_int_op(-1, ==, curve25519_public_from_base64(&key3, buf)); + tt_int_op(-1, OP_EQ, curve25519_public_from_base64(&key3, buf));

strlcpy(buf, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", sizeof(buf)); - tt_int_op(-1, ==, curve25519_public_from_base64(&key3, buf)); + tt_int_op(-1, OP_EQ, curve25519_public_from_base64(&key3, buf));

done: ; @@ -1472,45 +1472,45 @@ test_crypto_curve25519_persist(void *arg)

(void)arg;

- tt_int_op(0,==,curve25519_keypair_generate(&keypair, 0)); + tt_int_op(0,OP_EQ,curve25519_keypair_generate(&keypair, 0));

- tt_int_op(0,==,curve25519_keypair_write_to_file(&keypair, fname, "testing")); - tt_int_op(0,==,curve25519_keypair_read_from_file(&keypair2, &tag, fname)); - tt_str_op(tag,==,"testing"); + tt_int_op(0,OP_EQ,curve25519_keypair_write_to_file(&keypair, fname, "testing")); + tt_int_op(0,OP_EQ,curve25519_keypair_read_from_file(&keypair2, &tag, fname)); + tt_str_op(tag,OP_EQ,"testing"); tor_free(tag);

- tt_mem_op(keypair.pubkey.public_key,==, + tt_mem_op(keypair.pubkey.public_key,OP_EQ, keypair2.pubkey.public_key, CURVE25519_PUBKEY_LEN); - tt_mem_op(keypair.seckey.secret_key,==, + tt_mem_op(keypair.seckey.secret_key,OP_EQ, keypair2.seckey.secret_key, CURVE25519_SECKEY_LEN);

content = read_file_to_str(fname, RFTS_BIN, &st); tt_assert(content); taglen = strlen("== c25519v1: testing =="); - tt_u64_op((uint64_t)st.st_size, ==, + tt_u64_op((uint64_t)st.st_size, OP_EQ, 32+CURVE25519_PUBKEY_LEN+CURVE25519_SECKEY_LEN); tt_assert(fast_memeq(content, "== c25519v1: testing ==", taglen)); tt_assert(tor_mem_is_zero(content+taglen, 32-taglen)); cp = content + 32; - tt_mem_op(keypair.seckey.secret_key,==, + tt_mem_op(keypair.seckey.secret_key,OP_EQ, cp, CURVE25519_SECKEY_LEN); cp += CURVE25519_SECKEY_LEN; - tt_mem_op(keypair.pubkey.public_key,==, + tt_mem_op(keypair.pubkey.public_key,OP_EQ, cp, CURVE25519_SECKEY_LEN);

tor_free(fname); fname = tor_strdup(get_fname("bogus_keypair"));

- tt_int_op(-1, ==, curve25519_keypair_read_from_file(&keypair2, &tag, fname)); + tt_int_op(-1, OP_EQ, curve25519_keypair_read_from_file(&keypair2, &tag, fname)); tor_free(tag);

content[69] ^= 0xff; - tt_int_op(0, ==, write_bytes_to_file(fname, content, (size_t)st.st_size, 1)); - tt_int_op(-1, ==, curve25519_keypair_read_from_file(&keypair2, &tag, fname)); + tt_int_op(0, OP_EQ, write_bytes_to_file(fname, content, (size_t)st.st_size, 1)); + tt_int_op(-1, OP_EQ, curve25519_keypair_read_from_file(&keypair2, &tag, fname));

done: tor_free(fname); @@ -1536,41 +1536,41 @@ test_crypto_ed25519_simple(void *arg)

(void)arg;

- tt_int_op(0, ==, ed25519_secret_key_generate(&sec1, 0)); - tt_int_op(0, ==, ed25519_secret_key_generate(&sec2, 1)); + tt_int_op(0, OP_EQ, ed25519_secret_key_generate(&sec1, 0)); + tt_int_op(0, OP_EQ, ed25519_secret_key_generate(&sec2, 1));

- tt_int_op(0, ==, ed25519_public_key_generate(&pub1, &sec1)); - tt_int_op(0, ==, ed25519_public_key_generate(&pub2, &sec1)); + tt_int_op(0, OP_EQ, ed25519_public_key_generate(&pub1, &sec1)); + tt_int_op(0, OP_EQ, ed25519_public_key_generate(&pub2, &sec1));

- tt_mem_op(pub1.pubkey, ==, pub2.pubkey, sizeof(pub1.pubkey)); + tt_mem_op(pub1.pubkey, OP_EQ, pub2.pubkey, sizeof(pub1.pubkey));

memcpy(&kp1.pubkey, &pub1, sizeof(pub1)); memcpy(&kp1.seckey, &sec1, sizeof(sec1)); - tt_int_op(0, ==, ed25519_sign(&sig1, msg, msg_len, &kp1)); - tt_int_op(0, ==, ed25519_sign(&sig2, msg, msg_len, &kp1)); + tt_int_op(0, OP_EQ, ed25519_sign(&sig1, msg, msg_len, &kp1)); + tt_int_op(0, OP_EQ, ed25519_sign(&sig2, msg, msg_len, &kp1));

/* Ed25519 signatures are deterministic */ - tt_mem_op(sig1.sig, ==, sig2.sig, sizeof(sig1.sig)); + tt_mem_op(sig1.sig, OP_EQ, sig2.sig, sizeof(sig1.sig));

/* Basic signature is valid. */ - tt_int_op(0, ==, ed25519_checksig(&sig1, msg, msg_len, &pub1)); + tt_int_op(0, OP_EQ, ed25519_checksig(&sig1, msg, msg_len, &pub1));

/* Altered signature doesn't work. */ sig1.sig[0] ^= 3; - tt_int_op(-1, ==, ed25519_checksig(&sig1, msg, msg_len, &pub1)); + tt_int_op(-1, OP_EQ, ed25519_checksig(&sig1, msg, msg_len, &pub1));

/* Wrong public key doesn't work. */ - tt_int_op(0, ==, ed25519_public_key_generate(&pub2, &sec2)); - tt_int_op(-1, ==, ed25519_checksig(&sig2, msg, msg_len, &pub2)); + tt_int_op(0, OP_EQ, ed25519_public_key_generate(&pub2, &sec2)); + tt_int_op(-1, OP_EQ, ed25519_checksig(&sig2, msg, msg_len, &pub2));

/* Wrong message doesn't work. */ - tt_int_op(0, ==, ed25519_checksig(&sig2, msg, msg_len, &pub1)); - tt_int_op(-1, ==, ed25519_checksig(&sig2, msg, msg_len-1, &pub1)); - tt_int_op(-1, ==, ed25519_checksig(&sig2, msg2, msg2_len, &pub1)); + tt_int_op(0, OP_EQ, ed25519_checksig(&sig2, msg, msg_len, &pub1)); + tt_int_op(-1, OP_EQ, ed25519_checksig(&sig2, msg, msg_len-1, &pub1)); + tt_int_op(-1, OP_EQ, ed25519_checksig(&sig2, msg2, msg2_len, &pub1));

/* Batch signature checking works with some bad. */ - tt_int_op(0, ==, ed25519_keypair_generate(&kp2, 0)); - tt_int_op(0, ==, ed25519_sign(&sig1, msg, msg_len, &kp2)); + tt_int_op(0, OP_EQ, ed25519_keypair_generate(&kp2, 0)); + tt_int_op(0, OP_EQ, ed25519_sign(&sig1, msg, msg_len, &kp2)); { ed25519_checkable_t ch[] = { { &pub1, sig2, msg, msg_len }, /*ok*/ @@ -1579,12 +1579,12 @@ test_crypto_ed25519_simple(void *arg) { &kp2.pubkey, sig1, msg, msg_len }, /*ok*/ }; int okay[4]; - tt_int_op(-2, ==, ed25519_checksig_batch(okay, ch, 4)); - tt_int_op(okay[0], ==, 1); - tt_int_op(okay[1], ==, 0); - tt_int_op(okay[2], ==, 0); - tt_int_op(okay[3], ==, 1); - tt_int_op(-2, ==, ed25519_checksig_batch(NULL, ch, 4)); + tt_int_op(-2, OP_EQ, ed25519_checksig_batch(okay, ch, 4)); + tt_int_op(okay[0], OP_EQ, 1); + tt_int_op(okay[1], OP_EQ, 0); + tt_int_op(okay[2], OP_EQ, 0); + tt_int_op(okay[3], OP_EQ, 1); + tt_int_op(-2, OP_EQ, ed25519_checksig_batch(NULL, ch, 4)); }

/* Batch signature checking works with all good. */ @@ -1594,10 +1594,10 @@ test_crypto_ed25519_simple(void *arg) { &kp2.pubkey, sig1, msg, msg_len }, /*ok*/ }; int okay[2]; - tt_int_op(0, ==, ed25519_checksig_batch(okay, ch, 2)); - tt_int_op(okay[0], ==, 1); - tt_int_op(okay[1], ==, 1); - tt_int_op(0, ==, ed25519_checksig_batch(NULL, ch, 2)); + tt_int_op(0, OP_EQ, ed25519_checksig_batch(okay, ch, 2)); + tt_int_op(okay[0], OP_EQ, 1); + tt_int_op(okay[1], OP_EQ, 1); + tt_int_op(0, OP_EQ, ed25519_checksig_batch(NULL, ch, 2)); }

done: @@ -1680,14 +1680,14 @@ test_crypto_ed25519_test_vectors(void *arg) base16_decode((char*)sk_seed, sizeof(sk_seed), items[i].sk, 64); ed25519_secret_key_from_seed(&kp.seckey, sk_seed); - tt_int_op(0, ==, ed25519_public_key_generate(&kp.pubkey, &kp.seckey)); + tt_int_op(0, OP_EQ, ed25519_public_key_generate(&kp.pubkey, &kp.seckey)); test_memeq_hex(kp.pubkey.pubkey, items[i].pk);

msg_len = strlen(items[i].msg) / 2; msg = tor_malloc(msg_len); base16_decode((char*)msg, msg_len, items[i].msg, strlen(items[i].msg));

- tt_int_op(0, ==, ed25519_sign(&sig, msg, msg_len, &kp)); + tt_int_op(0, OP_EQ, ed25519_sign(&sig, msg, msg_len, &kp)); test_memeq_hex(sig.sig, items[i].sig);

tor_free(msg); @@ -1707,14 +1707,14 @@ test_crypto_ed25519_encode(void *arg) (void) arg;

/* Test roundtrip. */ - tt_int_op(0, ==, ed25519_keypair_generate(&kp, 0)); - tt_int_op(0, ==, ed25519_public_to_base64(buf, &kp.pubkey)); - tt_int_op(ED25519_BASE64_LEN, ==, strlen(buf)); - tt_int_op(0, ==, ed25519_public_from_base64(&pk, buf)); - tt_mem_op(kp.pubkey.pubkey, ==, pk.pubkey, ED25519_PUBKEY_LEN); + tt_int_op(0, OP_EQ, ed25519_keypair_generate(&kp, 0)); + tt_int_op(0, OP_EQ, ed25519_public_to_base64(buf, &kp.pubkey)); + tt_int_op(ED25519_BASE64_LEN, OP_EQ, strlen(buf)); + tt_int_op(0, OP_EQ, ed25519_public_from_base64(&pk, buf)); + tt_mem_op(kp.pubkey.pubkey, OP_EQ, pk.pubkey, ED25519_PUBKEY_LEN);

/* Test known value. */ - tt_int_op(0, ==, ed25519_public_from_base64(&pk, + tt_int_op(0, OP_EQ, ed25519_public_from_base64(&pk, "lVIuIctLjbGZGU5wKMNXxXlSE3cW4kaqkqm04u6pxvM")); test_memeq_hex(pk.pubkey, "95522e21cb4b8db199194e7028c357c57952137716e246aa92a9b4e2eea9c6f3"); @@ -1740,21 +1740,21 @@ test_crypto_ed25519_convert(void *arg) int bit=0; ed25519_signature_t sig;

- tt_int_op(0,==,curve25519_keypair_generate(&curve25519_keypair, i&1)); - tt_int_op(0,==,ed25519_keypair_from_curve25519_keypair( + tt_int_op(0,OP_EQ,curve25519_keypair_generate(&curve25519_keypair, i&1)); + tt_int_op(0,OP_EQ,ed25519_keypair_from_curve25519_keypair( &ed25519_keypair, &bit, &curve25519_keypair)); - tt_int_op(0,==,ed25519_public_key_from_curve25519_public_key( + tt_int_op(0,OP_EQ,ed25519_public_key_from_curve25519_public_key( &ed25519_pubkey, &curve25519_keypair.pubkey, bit)); - tt_mem_op(ed25519_pubkey.pubkey, ==, ed25519_keypair.pubkey.pubkey, 32); + tt_mem_op(ed25519_pubkey.pubkey, OP_EQ, ed25519_keypair.pubkey.pubkey, 32);

- tt_int_op(0,==,ed25519_sign(&sig, msg, sizeof(msg), &ed25519_keypair)); - tt_int_op(0,==,ed25519_checksig(&sig, msg, sizeof(msg), + tt_int_op(0,OP_EQ,ed25519_sign(&sig, msg, sizeof(msg), &ed25519_keypair)); + tt_int_op(0,OP_EQ,ed25519_checksig(&sig, msg, sizeof(msg), &ed25519_pubkey));

- tt_int_op(-1,==,ed25519_checksig(&sig, msg, sizeof(msg)-1, + tt_int_op(-1,OP_EQ,ed25519_checksig(&sig, msg, sizeof(msg)-1, &ed25519_pubkey)); sig.sig[0] ^= 15; - tt_int_op(-1,==,ed25519_checksig(&sig, msg, sizeof(msg), + tt_int_op(-1,OP_EQ,ed25519_checksig(&sig, msg, sizeof(msg), &ed25519_pubkey)); }

@@ -1782,26 +1782,26 @@ test_crypto_ed25519_blinding(void *arg)

crypto_rand((char*) blinding, sizeof(blinding));

- tt_int_op(0,==,ed25519_keypair_generate(&ed25519_keypair, 0)); - tt_int_op(0,==,ed25519_keypair_blind(&ed25519_keypair_blinded, + tt_int_op(0,OP_EQ,ed25519_keypair_generate(&ed25519_keypair, 0)); + tt_int_op(0,OP_EQ,ed25519_keypair_blind(&ed25519_keypair_blinded, &ed25519_keypair, blinding));

- tt_int_op(0,==,ed25519_public_blind(&ed25519_pubkey_blinded, + tt_int_op(0,OP_EQ,ed25519_public_blind(&ed25519_pubkey_blinded, &ed25519_keypair.pubkey, blinding));

- tt_mem_op(ed25519_pubkey_blinded.pubkey, ==, + tt_mem_op(ed25519_pubkey_blinded.pubkey, OP_EQ, ed25519_keypair_blinded.pubkey.pubkey, 32);

- tt_int_op(0,==,ed25519_sign(&sig, msg, sizeof(msg), + tt_int_op(0,OP_EQ,ed25519_sign(&sig, msg, sizeof(msg), &ed25519_keypair_blinded));

- tt_int_op(0,==,ed25519_checksig(&sig, msg, sizeof(msg), + tt_int_op(0,OP_EQ,ed25519_checksig(&sig, msg, sizeof(msg), &ed25519_pubkey_blinded));

- tt_int_op(-1,==,ed25519_checksig(&sig, msg, sizeof(msg)-1, + tt_int_op(-1,OP_EQ,ed25519_checksig(&sig, msg, sizeof(msg)-1, &ed25519_pubkey_blinded)); sig.sig[0] ^= 15; - tt_int_op(-1,==,ed25519_checksig(&sig, msg, sizeof(msg), + tt_int_op(-1,OP_EQ,ed25519_checksig(&sig, msg, sizeof(msg), &ed25519_pubkey_blinded)); }

@@ -1829,43 +1829,43 @@ test_crypto_ed25519_testvectors(void *arg) #define DECODE(p,s) base16_decode((char*)(p),sizeof(p),(s),strlen(s)) #define EQ(a,h) test_memeq_hex((const char*)(a), (h))

- tt_int_op(0, ==, DECODE(sk, ED25519_SECRET_KEYS[i])); - tt_int_op(0, ==, DECODE(blinding_param, ED25519_BLINDING_PARAMS[i])); + tt_int_op(0, OP_EQ, DECODE(sk, ED25519_SECRET_KEYS[i])); + tt_int_op(0, OP_EQ, DECODE(blinding_param, ED25519_BLINDING_PARAMS[i]));

- tt_int_op(0, ==, ed25519_secret_key_from_seed(&esk, sk)); + tt_int_op(0, OP_EQ, ed25519_secret_key_from_seed(&esk, sk)); EQ(esk.seckey, ED25519_EXPANDED_SECRET_KEYS[i]);

- tt_int_op(0, ==, ed25519_public_key_generate(&pk, &esk)); + tt_int_op(0, OP_EQ, ed25519_public_key_generate(&pk, &esk)); EQ(pk.pubkey, ED25519_PUBLIC_KEYS[i]);

memcpy(&curvekp.seckey.secret_key, esk.seckey, 32); curve25519_public_key_generate(&curvekp.pubkey, &curvekp.seckey);

- tt_int_op(0, ==, + tt_int_op(0, OP_EQ, ed25519_keypair_from_curve25519_keypair(&keypair, &sign, &curvekp)); - tt_int_op(0, ==, ed25519_public_key_from_curve25519_public_key( + tt_int_op(0, OP_EQ, ed25519_public_key_from_curve25519_public_key( &pkfromcurve, &curvekp.pubkey, sign)); - tt_mem_op(keypair.pubkey.pubkey, ==, pkfromcurve.pubkey, 32); + tt_mem_op(keypair.pubkey.pubkey, OP_EQ, pkfromcurve.pubkey, 32); EQ(curvekp.pubkey.public_key, ED25519_CURVE25519_PUBLIC_KEYS[i]);

/* Self-signing */ memcpy(&keypair.seckey, &esk, sizeof(esk)); memcpy(&keypair.pubkey, &pk, sizeof(pk));

- tt_int_op(0, ==, ed25519_sign(&sig, pk.pubkey, 32, &keypair)); + tt_int_op(0, OP_EQ, ed25519_sign(&sig, pk.pubkey, 32, &keypair));

EQ(sig.sig, ED25519_SELF_SIGNATURES[i]);

/* Blinding */ - tt_int_op(0, ==, + tt_int_op(0, OP_EQ, ed25519_keypair_blind(&blind_keypair, &keypair, blinding_param)); - tt_int_op(0, ==, + tt_int_op(0, OP_EQ, ed25519_public_blind(&blind_pk, &pk, blinding_param));

EQ(blind_keypair.seckey.seckey, ED25519_BLINDED_SECRET_KEYS[i]); EQ(blind_pk.pubkey, ED25519_BLINDED_PUBLIC_KEYS[i]);

- tt_mem_op(blind_pk.pubkey, ==, blind_keypair.pubkey.pubkey, 32); + tt_mem_op(blind_pk.pubkey, OP_EQ, blind_keypair.pubkey.pubkey, 32);

#undef DECODE #undef EQ @@ -1962,7 +1962,7 @@ test_crypto_siphash(void *arg) for (i = 0; i < 64; ++i) { uint64_t r = siphash24(input, i, &K); for (j = 0; j < 8; ++j) { - tt_int_op( (r >> (j*8)) & 0xff, ==, VECTORS[i][j]); + tt_int_op( (r >> (j*8)) & 0xff, OP_EQ, VECTORS[i][j]); } }

diff --git a/src/test/test_dir.c b/src/test/test_dir.c index c7e22d8..cdf16ad 100644 --- a/src/test/test_dir.c +++ b/src/test/test_dir.c @@ -180,7 +180,7 @@ test_dir_formats(void *arg) buf[strlen(buf2)] = '\0'; /* Don't compare the sig; it's never the same * twice */

- tt_str_op(buf,==, buf2); + tt_str_op(buf,OP_EQ, buf2); tor_free(buf);

buf = router_dump_router_to_string(r1, pk2); @@ -188,12 +188,12 @@ test_dir_formats(void *arg) cp = buf; rp1 = router_parse_entry_from_string((const char*)cp,NULL,1,0,NULL,NULL); tt_assert(rp1); - tt_int_op(rp1->addr,==, r1->addr); - tt_int_op(rp1->or_port,==, r1->or_port); + tt_int_op(rp1->addr,OP_EQ, r1->addr); + tt_int_op(rp1->or_port,OP_EQ, r1->or_port); //test_eq(rp1->dir_port, r1->dir_port); - tt_int_op(rp1->bandwidthrate,==, r1->bandwidthrate); - tt_int_op(rp1->bandwidthburst,==, r1->bandwidthburst); - tt_int_op(rp1->bandwidthcapacity,==, r1->bandwidthcapacity); + tt_int_op(rp1->bandwidthrate,OP_EQ, r1->bandwidthrate); + tt_int_op(rp1->bandwidthburst,OP_EQ, r1->bandwidthburst); + tt_int_op(rp1->bandwidthcapacity,OP_EQ, r1->bandwidthcapacity); tt_assert(crypto_pk_cmp_keys(rp1->onion_pkey, pk1) == 0); tt_assert(crypto_pk_cmp_keys(rp1->identity_pkey, pk2) == 0); //tt_assert(rp1->exit_policy == NULL); @@ -224,40 +224,40 @@ test_dir_formats(void *arg) buf = router_dump_router_to_string(r2, pk1); buf[strlen(buf2)] = '\0'; /* Don't compare the sig; it's never the same * twice */ - tt_str_op(buf,==, buf2); + tt_str_op(buf,OP_EQ, buf2); tor_free(buf);

buf = router_dump_router_to_string(r2, pk1); cp = buf; rp2 = router_parse_entry_from_string((const char*)cp,NULL,1,0,NULL,NULL); tt_assert(rp2); - tt_int_op(rp2->addr,==, r2->addr); - tt_int_op(rp2->or_port,==, r2->or_port); - tt_int_op(rp2->dir_port,==, r2->dir_port); - tt_int_op(rp2->bandwidthrate,==, r2->bandwidthrate); - tt_int_op(rp2->bandwidthburst,==, r2->bandwidthburst); - tt_int_op(rp2->bandwidthcapacity,==, r2->bandwidthcapacity); - tt_mem_op(rp2->onion_curve25519_pkey->public_key,==, + tt_int_op(rp2->addr,OP_EQ, r2->addr); + tt_int_op(rp2->or_port,OP_EQ, r2->or_port); + tt_int_op(rp2->dir_port,OP_EQ, r2->dir_port); + tt_int_op(rp2->bandwidthrate,OP_EQ, r2->bandwidthrate); + tt_int_op(rp2->bandwidthburst,OP_EQ, r2->bandwidthburst); + tt_int_op(rp2->bandwidthcapacity,OP_EQ, r2->bandwidthcapacity); + tt_mem_op(rp2->onion_curve25519_pkey->public_key,OP_EQ, r2->onion_curve25519_pkey->public_key, CURVE25519_PUBKEY_LEN); tt_assert(crypto_pk_cmp_keys(rp2->onion_pkey, pk2) == 0); tt_assert(crypto_pk_cmp_keys(rp2->identity_pkey, pk1) == 0);

- tt_int_op(smartlist_len(rp2->exit_policy),==, 2); + tt_int_op(smartlist_len(rp2->exit_policy),OP_EQ, 2);

p = smartlist_get(rp2->exit_policy, 0); - tt_int_op(p->policy_type,==, ADDR_POLICY_ACCEPT); + tt_int_op(p->policy_type,OP_EQ, ADDR_POLICY_ACCEPT); tt_assert(tor_addr_is_null(&p->addr)); - tt_int_op(p->maskbits,==, 0); - tt_int_op(p->prt_min,==, 80); - tt_int_op(p->prt_max,==, 80); + tt_int_op(p->maskbits,OP_EQ, 0); + tt_int_op(p->prt_min,OP_EQ, 80); + tt_int_op(p->prt_max,OP_EQ, 80);

p = smartlist_get(rp2->exit_policy, 1); - tt_int_op(p->policy_type,==, ADDR_POLICY_REJECT); + tt_int_op(p->policy_type,OP_EQ, ADDR_POLICY_REJECT); tt_assert(tor_addr_eq(&p->addr, &ex2->addr)); - tt_int_op(p->maskbits,==, 8); - tt_int_op(p->prt_min,==, 24); - tt_int_op(p->prt_max,==, 24); + tt_int_op(p->maskbits,OP_EQ, 8); + tt_int_op(p->prt_min,OP_EQ, 24); + tt_int_op(p->prt_max,OP_EQ, 24);

#if 0 /* Okay, now for the directories. */ @@ -312,7 +312,7 @@ test_dir_routerparse_bad(void *arg) again = 999; \ ri = router_parse_entry_from_string((s), NULL, 0, 0, NULL, &again); \ tt_assert(ri == NULL); \ - tt_int_op(again, ==, (againval)); \ + tt_int_op(again, OP_EQ, (againval)); \ } while (0)

CHECK_OK(EX_RI_MINIMAL); @@ -404,7 +404,7 @@ test_dir_extrainfo_parsing(void *arg) again = 999; \ ei = extrainfo_parse_entry_from_string((s), NULL, 0, map, &again); \ tt_assert(ei == NULL); \ - tt_int_op(again, ==, (againval)); \ + tt_int_op(again, OP_EQ, (againval)); \ } while (0) #define ADD(name) \ do { \ @@ -412,7 +412,7 @@ test_dir_extrainfo_parsing(void *arg) crypto_pk_t *pk = ri->identity_pkey = crypto_pk_new(); \ tt_assert(! crypto_pk_read_public_key_from_string(pk, \ name##_KEY, strlen(name##_KEY))); \ - tt_int_op(0,==,base16_decode(d, 20, name##_FP, strlen(name##_FP))); \ + tt_int_op(0,OP_EQ,base16_decode(d, 20, name##_FP, strlen(name##_FP))); \ digestmap_set((digestmap_t*)map, d, ri); \ ri = NULL; \ } while (0) @@ -490,20 +490,20 @@ test_dir_parse_router_list(void *arg)

/* First, parse the routers. */ cp = list; - tt_int_op(0,==, + tt_int_op(0,OP_EQ, router_parse_list_from_string(&cp, NULL, dest, SAVED_NOWHERE, 0, 0, NULL, invalid)); - tt_int_op(2, ==, smartlist_len(dest)); - tt_ptr_op(cp, ==, list + strlen(list)); + tt_int_op(2, OP_EQ, smartlist_len(dest)); + tt_ptr_op(cp, OP_EQ, list + strlen(list));

routerinfo_t *r = smartlist_get(dest, 0); - tt_mem_op(r->cache_info.signed_descriptor_body, ==, + tt_mem_op(r->cache_info.signed_descriptor_body, OP_EQ, EX_RI_MINIMAL, strlen(EX_RI_MINIMAL)); r = smartlist_get(dest, 1); - tt_mem_op(r->cache_info.signed_descriptor_body, ==, + tt_mem_op(r->cache_info.signed_descriptor_body, OP_EQ, EX_RI_MAXIMAL, strlen(EX_RI_MAXIMAL));

- tt_int_op(2, ==, smartlist_len(invalid)); + tt_int_op(2, OP_EQ, smartlist_len(invalid)); test_memeq_hex(smartlist_get(invalid, 0), "ab9eeaa95e7d45740185b4e519c76ead756277a9"); test_memeq_hex(smartlist_get(invalid, 1), @@ -523,18 +523,18 @@ test_dir_parse_router_list(void *arg) ADD(EX_EI_BAD_NICKNAME); ADD(EX_EI_BAD_PUBLISHED); cp = list; - tt_int_op(0,==, + tt_int_op(0,OP_EQ, router_parse_list_from_string(&cp, NULL, dest, SAVED_NOWHERE, 1, 0, NULL, invalid)); - tt_int_op(2, ==, smartlist_len(dest)); + tt_int_op(2, OP_EQ, smartlist_len(dest)); extrainfo_t *e = smartlist_get(dest, 0); - tt_mem_op(e->cache_info.signed_descriptor_body, ==, + tt_mem_op(e->cache_info.signed_descriptor_body, OP_EQ, EX_EI_MAXIMAL, strlen(EX_EI_MAXIMAL)); e = smartlist_get(dest, 1); - tt_mem_op(e->cache_info.signed_descriptor_body, ==, + tt_mem_op(e->cache_info.signed_descriptor_body, OP_EQ, EX_EI_MINIMAL, strlen(EX_EI_MINIMAL));

- tt_int_op(2, ==, smartlist_len(invalid)); + tt_int_op(2, OP_EQ, smartlist_len(invalid)); test_memeq_hex(smartlist_get(invalid, 0), "d5df4aa62ee9ffc9543d41150c9864908e0390af"); test_memeq_hex(smartlist_get(invalid, 1), @@ -608,7 +608,7 @@ test_dir_load_routers(void *arg)

#define ADD(str) \ do { \ - tt_int_op(0,==,router_get_router_hash(str, strlen(str), buf)); \ + tt_int_op(0,OP_EQ,router_get_router_hash(str, strlen(str), buf)); \ smartlist_add(wanted, tor_strdup(hex_str(buf, DIGEST_LEN))); \ } while (0)

@@ -631,34 +631,34 @@ test_dir_load_routers(void *arg) ADD(EX_RI_BAD_TOKENS);

char *list = smartlist_join_strings(chunks, "", 0, NULL); - tt_int_op(1, ==, + tt_int_op(1, OP_EQ, router_load_routers_from_string(list, NULL, SAVED_IN_JOURNAL, wanted, 1, NULL));

/* The "maximal" router was added. */ /* "minimal" was not. */ - tt_int_op(smartlist_len(router_get_routerlist()->routers),==,1); + tt_int_op(smartlist_len(router_get_routerlist()->routers),OP_EQ,1); routerinfo_t *r = smartlist_get(router_get_routerlist()->routers, 0); test_memeq_hex(r->cache_info.signed_descriptor_digest, "581D8A368A0FA854ECDBFAB841D88B3F1B004038"); - tt_int_op(dls_minimal.n_download_failures, ==, 0); - tt_int_op(dls_maximal.n_download_failures, ==, 0); + tt_int_op(dls_minimal.n_download_failures, OP_EQ, 0); + tt_int_op(dls_maximal.n_download_failures, OP_EQ, 0);

/* "Bad fingerprint" and "Bad tokens" should have gotten marked * non-retriable. */ - tt_want_int_op(mock_router_get_dl_status_calls, ==, 2); - tt_want_int_op(mock_router_get_dl_status_unrecognized, ==, 0); - tt_int_op(dls_bad_fingerprint.n_download_failures, ==, 255); - tt_int_op(dls_bad_tokens.n_download_failures, ==, 255); + tt_want_int_op(mock_router_get_dl_status_calls, OP_EQ, 2); + tt_want_int_op(mock_router_get_dl_status_unrecognized, OP_EQ, 0); + tt_int_op(dls_bad_fingerprint.n_download_failures, OP_EQ, 255); + tt_int_op(dls_bad_tokens.n_download_failures, OP_EQ, 255);

/* bad_sig2 and bad ports" are retriable -- one since only the signature * was bad, and one because we didn't ask for it. */ - tt_int_op(dls_bad_sig2.n_download_failures, ==, 0); - tt_int_op(dls_bad_ports.n_download_failures, ==, 0); + tt_int_op(dls_bad_sig2.n_download_failures, OP_EQ, 0); + tt_int_op(dls_bad_ports.n_download_failures, OP_EQ, 0);

/* Wanted still contains "BAD_SIG2" */ - tt_int_op(smartlist_len(wanted), ==, 1); - tt_str_op(smartlist_get(wanted, 0), ==, + tt_int_op(smartlist_len(wanted), OP_EQ, 1); + tt_str_op(smartlist_get(wanted, 0), OP_EQ, "E0A3753CEFD54128EAB239F294954121DB23D2EF");

#undef ADD @@ -725,7 +725,7 @@ test_dir_load_extrainfo(void *arg)

#define ADD(str) \ do { \ - tt_int_op(0,==,router_get_extrainfo_hash(str, strlen(str), buf)); \ + tt_int_op(0,OP_EQ,router_get_extrainfo_hash(str, strlen(str), buf)); \ smartlist_add(wanted, tor_strdup(hex_str(buf, DIGEST_LEN))); \ } while (0)

@@ -752,7 +752,7 @@ test_dir_load_extrainfo(void *arg) /* The "maximal" router was added. */ /* "minimal" was also added, even though we didn't ask for it, since * that's what we do with extrainfos. */ - tt_int_op(smartlist_len(mock_ei_insert_list),==,2); + tt_int_op(smartlist_len(mock_ei_insert_list),OP_EQ,2);

extrainfo_t *e = smartlist_get(mock_ei_insert_list, 0); test_memeq_hex(e->cache_info.signed_descriptor_digest, @@ -761,22 +761,22 @@ test_dir_load_extrainfo(void *arg) e = smartlist_get(mock_ei_insert_list, 1); test_memeq_hex(e->cache_info.signed_descriptor_digest, "47803B02A0E70E9E8BDA226CB1D74DE354D67DFF"); - tt_int_op(dls_minimal.n_download_failures, ==, 0); - tt_int_op(dls_maximal.n_download_failures, ==, 0); + tt_int_op(dls_minimal.n_download_failures, OP_EQ, 0); + tt_int_op(dls_maximal.n_download_failures, OP_EQ, 0);

/* "Bad nickname" and "Bad tokens" should have gotten marked * non-retriable. */ - tt_want_int_op(mock_get_by_ei_dd_calls, ==, 2); - tt_want_int_op(mock_get_by_ei_dd_unrecognized, ==, 0); - tt_int_op(sd_ei_bad_nickname.ei_dl_status.n_download_failures, ==, 255); - tt_int_op(sd_ei_bad_tokens.ei_dl_status.n_download_failures, ==, 255); + tt_want_int_op(mock_get_by_ei_dd_calls, OP_EQ, 2); + tt_want_int_op(mock_get_by_ei_dd_unrecognized, OP_EQ, 0); + tt_int_op(sd_ei_bad_nickname.ei_dl_status.n_download_failures, OP_EQ, 255); + tt_int_op(sd_ei_bad_tokens.ei_dl_status.n_download_failures, OP_EQ, 255);

/* bad_ports is retriable -- because we didn't ask for it. */ - tt_int_op(dls_bad_ports.n_download_failures, ==, 0); + tt_int_op(dls_bad_ports.n_download_failures, OP_EQ, 0);

/* Wanted still contains "BAD_SIG2" */ - tt_int_op(smartlist_len(wanted), ==, 1); - tt_str_op(smartlist_get(wanted, 0), ==, + tt_int_op(smartlist_len(wanted), OP_EQ, 1); + tt_str_op(smartlist_get(wanted, 0), OP_EQ, "16D387D3A58F7DB3CF46638F8D0B90C45C7D769C");

#undef ADD @@ -797,50 +797,50 @@ test_dir_versions(void *arg)

/* Try out version parsing functionality */ (void)arg; - tt_int_op(0,==, tor_version_parse("0.3.4pre2-cvs", &ver1)); - tt_int_op(0,==, ver1.major); - tt_int_op(3,==, ver1.minor); - tt_int_op(4,==, ver1.micro); - tt_int_op(VER_PRE,==, ver1.status); - tt_int_op(2,==, ver1.patchlevel); - tt_int_op(0,==, tor_version_parse("0.3.4rc1", &ver1)); - tt_int_op(0,==, ver1.major); - tt_int_op(3,==, ver1.minor); - tt_int_op(4,==, ver1.micro); - tt_int_op(VER_RC,==, ver1.status); - tt_int_op(1,==, ver1.patchlevel); - tt_int_op(0,==, tor_version_parse("1.3.4", &ver1)); - tt_int_op(1,==, ver1.major); - tt_int_op(3,==, ver1.minor); - tt_int_op(4,==, ver1.micro); - tt_int_op(VER_RELEASE,==, ver1.status); - tt_int_op(0,==, ver1.patchlevel); - tt_int_op(0,==, tor_version_parse("1.3.4.999", &ver1)); - tt_int_op(1,==, ver1.major); - tt_int_op(3,==, ver1.minor); - tt_int_op(4,==, ver1.micro); - tt_int_op(VER_RELEASE,==, ver1.status); - tt_int_op(999,==, ver1.patchlevel); - tt_int_op(0,==, tor_version_parse("0.1.2.4-alpha", &ver1)); - tt_int_op(0,==, ver1.major); - tt_int_op(1,==, ver1.minor); - tt_int_op(2,==, ver1.micro); - tt_int_op(4,==, ver1.patchlevel); - tt_int_op(VER_RELEASE,==, ver1.status); - tt_str_op("alpha",==, ver1.status_tag); - tt_int_op(0,==, tor_version_parse("0.1.2.4", &ver1)); - tt_int_op(0,==, ver1.major); - tt_int_op(1,==, ver1.minor); - tt_int_op(2,==, ver1.micro); - tt_int_op(4,==, ver1.patchlevel); - tt_int_op(VER_RELEASE,==, ver1.status); - tt_str_op("",==, ver1.status_tag); + tt_int_op(0,OP_EQ, tor_version_parse("0.3.4pre2-cvs", &ver1)); + tt_int_op(0,OP_EQ, ver1.major); + tt_int_op(3,OP_EQ, ver1.minor); + tt_int_op(4,OP_EQ, ver1.micro); + tt_int_op(VER_PRE,OP_EQ, ver1.status); + tt_int_op(2,OP_EQ, ver1.patchlevel); + tt_int_op(0,OP_EQ, tor_version_parse("0.3.4rc1", &ver1)); + tt_int_op(0,OP_EQ, ver1.major); + tt_int_op(3,OP_EQ, ver1.minor); + tt_int_op(4,OP_EQ, ver1.micro); + tt_int_op(VER_RC,OP_EQ, ver1.status); + tt_int_op(1,OP_EQ, ver1.patchlevel); + tt_int_op(0,OP_EQ, tor_version_parse("1.3.4", &ver1)); + tt_int_op(1,OP_EQ, ver1.major); + tt_int_op(3,OP_EQ, ver1.minor); + tt_int_op(4,OP_EQ, ver1.micro); + tt_int_op(VER_RELEASE,OP_EQ, ver1.status); + tt_int_op(0,OP_EQ, ver1.patchlevel); + tt_int_op(0,OP_EQ, tor_version_parse("1.3.4.999", &ver1)); + tt_int_op(1,OP_EQ, ver1.major); + tt_int_op(3,OP_EQ, ver1.minor); + tt_int_op(4,OP_EQ, ver1.micro); + tt_int_op(VER_RELEASE,OP_EQ, ver1.status); + tt_int_op(999,OP_EQ, ver1.patchlevel); + tt_int_op(0,OP_EQ, tor_version_parse("0.1.2.4-alpha", &ver1)); + tt_int_op(0,OP_EQ, ver1.major); + tt_int_op(1,OP_EQ, ver1.minor); + tt_int_op(2,OP_EQ, ver1.micro); + tt_int_op(4,OP_EQ, ver1.patchlevel); + tt_int_op(VER_RELEASE,OP_EQ, ver1.status); + tt_str_op("alpha",OP_EQ, ver1.status_tag); + tt_int_op(0,OP_EQ, tor_version_parse("0.1.2.4", &ver1)); + tt_int_op(0,OP_EQ, ver1.major); + tt_int_op(1,OP_EQ, ver1.minor); + tt_int_op(2,OP_EQ, ver1.micro); + tt_int_op(4,OP_EQ, ver1.patchlevel); + tt_int_op(VER_RELEASE,OP_EQ, ver1.status); + tt_str_op("",OP_EQ, ver1.status_tag);

#define tt_versionstatus_op(vs1, op, vs2) \ tt_assert_test_type(vs1,vs2,#vs1" "#op" "#vs2,version_status_t, \ (val1_ op val2_),"%d",TT_EXIT_TEST_FUNCTION) #define test_v_i_o(val, ver, lst) \ - tt_versionstatus_op(val, ==, tor_version_is_obsolete(ver, lst)) + tt_versionstatus_op(val, OP_EQ, tor_version_is_obsolete(ver, lst))

/* make sure tor_version_is_obsolete() works */ test_v_i_o(VS_OLD, "0.0.1", "Tor 0.0.2"); @@ -867,42 +867,42 @@ test_dir_versions(void *arg) /* On list, not newer than any on same series. */ test_v_i_o(VS_UNRECOMMENDED, "0.1.0.1", "Tor 0.1.0.2,Tor 0.0.9.5,Tor 0.1.1.0"); - tt_int_op(0,==, tor_version_as_new_as("Tor 0.0.5", "0.0.9pre1-cvs")); - tt_int_op(1,==, tor_version_as_new_as( + tt_int_op(0,OP_EQ, tor_version_as_new_as("Tor 0.0.5", "0.0.9pre1-cvs")); + tt_int_op(1,OP_EQ, tor_version_as_new_as( "Tor 0.0.8 on Darwin 64-121-192-100.c3-0." "sfpo-ubr1.sfrn-sfpo.ca.cable.rcn.com Power Macintosh", "0.0.8rc2")); - tt_int_op(0,==, tor_version_as_new_as( + tt_int_op(0,OP_EQ, tor_version_as_new_as( "Tor 0.0.8 on Darwin 64-121-192-100.c3-0." "sfpo-ubr1.sfrn-sfpo.ca.cable.rcn.com Power Macintosh", "0.0.8.2"));

/* Now try svn revisions. */ - tt_int_op(1,==, tor_version_as_new_as("Tor 0.2.1.0-dev (r100)", + tt_int_op(1,OP_EQ, tor_version_as_new_as("Tor 0.2.1.0-dev (r100)", "Tor 0.2.1.0-dev (r99)")); - tt_int_op(1,==, tor_version_as_new_as("Tor 0.2.1.0-dev (r100) on Banana Jr", + tt_int_op(1,OP_EQ, tor_version_as_new_as("Tor 0.2.1.0-dev (r100) on Banana Jr", "Tor 0.2.1.0-dev (r99) on Hal 9000")); - tt_int_op(1,==, tor_version_as_new_as("Tor 0.2.1.0-dev (r100)", + tt_int_op(1,OP_EQ, tor_version_as_new_as("Tor 0.2.1.0-dev (r100)", "Tor 0.2.1.0-dev on Colossus")); - tt_int_op(0,==, tor_version_as_new_as("Tor 0.2.1.0-dev (r99)", + tt_int_op(0,OP_EQ, tor_version_as_new_as("Tor 0.2.1.0-dev (r99)", "Tor 0.2.1.0-dev (r100)")); - tt_int_op(0,==, tor_version_as_new_as("Tor 0.2.1.0-dev (r99) on MCP", + tt_int_op(0,OP_EQ, tor_version_as_new_as("Tor 0.2.1.0-dev (r99) on MCP", "Tor 0.2.1.0-dev (r100) on AM")); - tt_int_op(0,==, tor_version_as_new_as("Tor 0.2.1.0-dev", + tt_int_op(0,OP_EQ, tor_version_as_new_as("Tor 0.2.1.0-dev", "Tor 0.2.1.0-dev (r99)")); - tt_int_op(1,==, tor_version_as_new_as("Tor 0.2.1.1", + tt_int_op(1,OP_EQ, tor_version_as_new_as("Tor 0.2.1.1", "Tor 0.2.1.0-dev (r99)"));

/* Now try git revisions */ - tt_int_op(0,==, tor_version_parse("0.5.6.7 (git-ff00ff)", &ver1)); - tt_int_op(0,==, ver1.major); - tt_int_op(5,==, ver1.minor); - tt_int_op(6,==, ver1.micro); - tt_int_op(7,==, ver1.patchlevel); - tt_int_op(3,==, ver1.git_tag_len); - tt_mem_op(ver1.git_tag,==, "\xff\x00\xff", 3); - tt_int_op(-1,==, tor_version_parse("0.5.6.7 (git-ff00xx)", &ver1)); - tt_int_op(-1,==, tor_version_parse("0.5.6.7 (git-ff00fff)", &ver1)); - tt_int_op(0,==, tor_version_parse("0.5.6.7 (git ff00fff)", &ver1)); + tt_int_op(0,OP_EQ, tor_version_parse("0.5.6.7 (git-ff00ff)", &ver1)); + tt_int_op(0,OP_EQ, ver1.major); + tt_int_op(5,OP_EQ, ver1.minor); + tt_int_op(6,OP_EQ, ver1.micro); + tt_int_op(7,OP_EQ, ver1.patchlevel); + tt_int_op(3,OP_EQ, ver1.git_tag_len); + tt_mem_op(ver1.git_tag,OP_EQ, "\xff\x00\xff", 3); + tt_int_op(-1,OP_EQ, tor_version_parse("0.5.6.7 (git-ff00xx)", &ver1)); + tt_int_op(-1,OP_EQ, tor_version_parse("0.5.6.7 (git-ff00fff)", &ver1)); + tt_int_op(0,OP_EQ, tor_version_parse("0.5.6.7 (git ff00fff)", &ver1)); done: ; } @@ -924,13 +924,13 @@ test_dir_fp_pairs(void *arg) "48657861646563696d616c2069736e277420736f-" "676f6f6420666f7220686964696e6720796f7572.z", sl);

- tt_int_op(smartlist_len(sl),==, 2); + tt_int_op(smartlist_len(sl),OP_EQ, 2); pair = smartlist_get(sl, 0); - tt_mem_op(pair->first,==, "Hexadecimal isn't so", DIGEST_LEN); - tt_mem_op(pair->second,==, "good for hiding your", DIGEST_LEN); + tt_mem_op(pair->first,OP_EQ, "Hexadecimal isn't so", DIGEST_LEN); + tt_mem_op(pair->second,OP_EQ, "good for hiding your", DIGEST_LEN); pair = smartlist_get(sl, 1); - tt_mem_op(pair->first,==, "secret data.\0\0\0\0\0\xff\xff\xff", DIGEST_LEN); - tt_mem_op(pair->second,==, "Use AES-256 instead.", DIGEST_LEN); + tt_mem_op(pair->first,OP_EQ, "secret data.\0\0\0\0\0\xff\xff\xff", DIGEST_LEN); + tt_mem_op(pair->second,OP_EQ, "Use AES-256 instead.", DIGEST_LEN);

done: SMARTLIST_FOREACH(sl, fp_pair_t *, pair, tor_free(pair)); @@ -961,56 +961,56 @@ test_dir_split_fps(void *testdata)

/* no flags set */ dir_split_resource_into_fingerprints("A+C+B", sl, NULL, 0); - tt_int_op(smartlist_len(sl), ==, 3); - tt_str_op(smartlist_get(sl, 0), ==, "A"); - tt_str_op(smartlist_get(sl, 1), ==, "C"); - tt_str_op(smartlist_get(sl, 2), ==, "B"); + tt_int_op(smartlist_len(sl), OP_EQ, 3); + tt_str_op(smartlist_get(sl, 0), OP_EQ, "A"); + tt_str_op(smartlist_get(sl, 1), OP_EQ, "C"); + tt_str_op(smartlist_get(sl, 2), OP_EQ, "B"); SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); smartlist_clear(sl);

/* uniq strings. */ dir_split_resource_into_fingerprints("A+C+B+A+B+B", sl, NULL, DSR_SORT_UNIQ); - tt_int_op(smartlist_len(sl), ==, 3); - tt_str_op(smartlist_get(sl, 0), ==, "A"); - tt_str_op(smartlist_get(sl, 1), ==, "B"); - tt_str_op(smartlist_get(sl, 2), ==, "C"); + tt_int_op(smartlist_len(sl), OP_EQ, 3); + tt_str_op(smartlist_get(sl, 0), OP_EQ, "A"); + tt_str_op(smartlist_get(sl, 1), OP_EQ, "B"); + tt_str_op(smartlist_get(sl, 2), OP_EQ, "C"); SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); smartlist_clear(sl);

/* Decode hex. */ dir_split_resource_into_fingerprints(HEX1"+"HEX2, sl, NULL, DSR_HEX); - tt_int_op(smartlist_len(sl), ==, 2); - test_mem_op_hex(smartlist_get(sl, 0), ==, HEX1); - test_mem_op_hex(smartlist_get(sl, 1), ==, HEX2); + tt_int_op(smartlist_len(sl), OP_EQ, 2); + test_mem_op_hex(smartlist_get(sl, 0), OP_EQ, HEX1); + test_mem_op_hex(smartlist_get(sl, 1), OP_EQ, HEX2); SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); smartlist_clear(sl);

/* decode hex and drop weirdness. */ dir_split_resource_into_fingerprints(HEX1"+bogus+"HEX2"+"HEX256_1, sl, NULL, DSR_HEX); - tt_int_op(smartlist_len(sl), ==, 2); - test_mem_op_hex(smartlist_get(sl, 0), ==, HEX1); - test_mem_op_hex(smartlist_get(sl, 1), ==, HEX2); + tt_int_op(smartlist_len(sl), OP_EQ, 2); + test_mem_op_hex(smartlist_get(sl, 0), OP_EQ, HEX1); + test_mem_op_hex(smartlist_get(sl, 1), OP_EQ, HEX2); SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); smartlist_clear(sl);

/* Decode long hex */ dir_split_resource_into_fingerprints(HEX256_1"+"HEX256_2"+"HEX2"+"HEX256_3, sl, NULL, DSR_HEX|DSR_DIGEST256); - tt_int_op(smartlist_len(sl), ==, 3); - test_mem_op_hex(smartlist_get(sl, 0), ==, HEX256_1); - test_mem_op_hex(smartlist_get(sl, 1), ==, HEX256_2); - test_mem_op_hex(smartlist_get(sl, 2), ==, HEX256_3); + tt_int_op(smartlist_len(sl), OP_EQ, 3); + test_mem_op_hex(smartlist_get(sl, 0), OP_EQ, HEX256_1); + test_mem_op_hex(smartlist_get(sl, 1), OP_EQ, HEX256_2); + test_mem_op_hex(smartlist_get(sl, 2), OP_EQ, HEX256_3); SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); smartlist_clear(sl);

/* Decode hex and sort. */ dir_split_resource_into_fingerprints(HEX1"+"HEX2"+"HEX3"+"HEX2, sl, NULL, DSR_HEX|DSR_SORT_UNIQ); - tt_int_op(smartlist_len(sl), ==, 3); - test_mem_op_hex(smartlist_get(sl, 0), ==, HEX3); - test_mem_op_hex(smartlist_get(sl, 1), ==, HEX2); - test_mem_op_hex(smartlist_get(sl, 2), ==, HEX1); + tt_int_op(smartlist_len(sl), OP_EQ, 3); + test_mem_op_hex(smartlist_get(sl, 0), OP_EQ, HEX3); + test_mem_op_hex(smartlist_get(sl, 1), OP_EQ, HEX2); + test_mem_op_hex(smartlist_get(sl, 2), OP_EQ, HEX1); SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); smartlist_clear(sl);

@@ -1019,34 +1019,34 @@ test_dir_split_fps(void *testdata) "+"HEX256_1, sl, NULL, DSR_HEX|DSR_DIGEST256|DSR_SORT_UNIQ); - tt_int_op(smartlist_len(sl), ==, 3); - test_mem_op_hex(smartlist_get(sl, 0), ==, HEX256_3); - test_mem_op_hex(smartlist_get(sl, 1), ==, HEX256_2); - test_mem_op_hex(smartlist_get(sl, 2), ==, HEX256_1); + tt_int_op(smartlist_len(sl), OP_EQ, 3); + test_mem_op_hex(smartlist_get(sl, 0), OP_EQ, HEX256_3); + test_mem_op_hex(smartlist_get(sl, 1), OP_EQ, HEX256_2); + test_mem_op_hex(smartlist_get(sl, 2), OP_EQ, HEX256_1); SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); smartlist_clear(sl);

/* Decode base64 */ dir_split_resource_into_fingerprints(B64_1"-"B64_2, sl, NULL, DSR_BASE64); - tt_int_op(smartlist_len(sl), ==, 2); - test_mem_op_hex(smartlist_get(sl, 0), ==, HEX1); - test_mem_op_hex(smartlist_get(sl, 1), ==, HEX2); + tt_int_op(smartlist_len(sl), OP_EQ, 2); + test_mem_op_hex(smartlist_get(sl, 0), OP_EQ, HEX1); + test_mem_op_hex(smartlist_get(sl, 1), OP_EQ, HEX2); SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); smartlist_clear(sl);

/* Decode long base64 */ dir_split_resource_into_fingerprints(B64_256_1"-"B64_256_2, sl, NULL, DSR_BASE64|DSR_DIGEST256); - tt_int_op(smartlist_len(sl), ==, 2); - test_mem_op_hex(smartlist_get(sl, 0), ==, HEX256_1); - test_mem_op_hex(smartlist_get(sl, 1), ==, HEX256_2); + tt_int_op(smartlist_len(sl), OP_EQ, 2); + test_mem_op_hex(smartlist_get(sl, 0), OP_EQ, HEX256_1); + test_mem_op_hex(smartlist_get(sl, 1), OP_EQ, HEX256_2); SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); smartlist_clear(sl);

dir_split_resource_into_fingerprints(B64_256_1, sl, NULL, DSR_BASE64|DSR_DIGEST256); - tt_int_op(smartlist_len(sl), ==, 1); - test_mem_op_hex(smartlist_get(sl, 0), ==, HEX256_1); + tt_int_op(smartlist_len(sl), OP_EQ, 1); + test_mem_op_hex(smartlist_get(sl, 0), OP_EQ, HEX256_1); SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp)); smartlist_clear(sl);

@@ -1140,7 +1140,7 @@ test_dir_measured_bw_kb_cache(void *arg) /* First, clear the cache and assert that it's empty */ (void)arg; dirserv_clear_measured_bw_cache(); - tt_int_op(dirserv_get_measured_bw_cache_size(),==, 0); + tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 0); /* * Set up test mbwls; none of the dirserv_cache_*() functions care about * the node_hex field. @@ -1153,49 +1153,49 @@ test_dir_measured_bw_kb_cache(void *arg) mbwl[2].bw_kb = 80; /* Try caching something */ dirserv_cache_measured_bw(&(mbwl[0]), curr); - tt_int_op(dirserv_get_measured_bw_cache_size(),==, 1); + tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 1); /* Okay, let's see if we can retrieve it */ tt_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,&bw, &as_of)); - tt_int_op(bw,==, 20); - tt_int_op(as_of,==, MBWC_INIT_TIME); + tt_int_op(bw,OP_EQ, 20); + tt_int_op(as_of,OP_EQ, MBWC_INIT_TIME); /* Try retrieving it without some outputs */ tt_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,NULL, NULL)); tt_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,&bw, NULL)); - tt_int_op(bw,==, 20); + tt_int_op(bw,OP_EQ, 20); tt_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,NULL,&as_of)); - tt_int_op(as_of,==, MBWC_INIT_TIME); + tt_int_op(as_of,OP_EQ, MBWC_INIT_TIME); /* Now expire it */ curr += MAX_MEASUREMENT_AGE + 1; dirserv_expire_measured_bw_cache(curr); /* Check that the cache is empty */ - tt_int_op(dirserv_get_measured_bw_cache_size(),==, 0); + tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 0); /* Check that we can't retrieve it */ tt_assert(!dirserv_query_measured_bw_cache_kb(mbwl[0].node_id, NULL,NULL)); /* Try caching a few things now */ dirserv_cache_measured_bw(&(mbwl[0]), curr); - tt_int_op(dirserv_get_measured_bw_cache_size(),==, 1); + tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 1); curr += MAX_MEASUREMENT_AGE / 4; dirserv_cache_measured_bw(&(mbwl[1]), curr); - tt_int_op(dirserv_get_measured_bw_cache_size(),==, 2); + tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 2); curr += MAX_MEASUREMENT_AGE / 4; dirserv_cache_measured_bw(&(mbwl[2]), curr); - tt_int_op(dirserv_get_measured_bw_cache_size(),==, 3); + tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 3); curr += MAX_MEASUREMENT_AGE / 4 + 1; /* Do an expire that's too soon to get any of them */ dirserv_expire_measured_bw_cache(curr); - tt_int_op(dirserv_get_measured_bw_cache_size(),==, 3); + tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 3); /* Push the oldest one off the cliff */ curr += MAX_MEASUREMENT_AGE / 4; dirserv_expire_measured_bw_cache(curr); - tt_int_op(dirserv_get_measured_bw_cache_size(),==, 2); + tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 2); /* And another... */ curr += MAX_MEASUREMENT_AGE / 4; dirserv_expire_measured_bw_cache(curr); - tt_int_op(dirserv_get_measured_bw_cache_size(),==, 1); + tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 1); /* This should empty it out again */ curr += MAX_MEASUREMENT_AGE / 4; dirserv_expire_measured_bw_cache(curr); - tt_int_op(dirserv_get_measured_bw_cache_size(),==, 0); + tt_int_op(dirserv_get_measured_bw_cache_size(),OP_EQ, 0);

done: return; @@ -1228,11 +1228,11 @@ test_dir_param_voting(void *arg) "abcd=20 c=60 cw=500 x-yz=-9 zzzzz=101", NULL, 0, 0); smartlist_split_string(vote4.net_params, "ab=900 abcd=200 c=1 cw=51 x-yz=100", NULL, 0, 0); - tt_int_op(100,==, networkstatus_get_param(&vote4, "x-yz", 50, 0, 300)); - tt_int_op(222,==, networkstatus_get_param(&vote4, "foobar", 222, 0, 300)); - tt_int_op(80,==, networkstatus_get_param(&vote4, "ab", 12, 0, 80)); - tt_int_op(-8,==, networkstatus_get_param(&vote4, "ab", -12, -100, -8)); - tt_int_op(0,==, networkstatus_get_param(&vote4, "foobar", 0, -100, 8)); + tt_int_op(100,OP_EQ, networkstatus_get_param(&vote4, "x-yz", 50, 0, 300)); + tt_int_op(222,OP_EQ, networkstatus_get_param(&vote4, "foobar", 222, 0, 300)); + tt_int_op(80,OP_EQ, networkstatus_get_param(&vote4, "ab", 12, 0, 80)); + tt_int_op(-8,OP_EQ, networkstatus_get_param(&vote4, "ab", -12, -100, -8)); + tt_int_op(0,OP_EQ, networkstatus_get_param(&vote4, "foobar", 0, -100, 8));

smartlist_add(votes, &vote1);

@@ -1240,59 +1240,59 @@ test_dir_param_voting(void *arg) * networks without many dirauths. */

res = dirvote_compute_params(votes, 12, 2); - tt_str_op(res,==, ""); + tt_str_op(res,OP_EQ, ""); tor_free(res);

res = dirvote_compute_params(votes, 12, 1); - tt_str_op(res,==, "ab=90 abcd=20 cw=50 x-yz=-99"); + tt_str_op(res,OP_EQ, "ab=90 abcd=20 cw=50 x-yz=-99"); tor_free(res);

smartlist_add(votes, &vote2);

res = dirvote_compute_params(votes, 12, 2); - tt_str_op(res,==, "ab=27 cw=5 x-yz=-99"); + tt_str_op(res,OP_EQ, "ab=27 cw=5 x-yz=-99"); tor_free(res);

res = dirvote_compute_params(votes, 12, 3); - tt_str_op(res,==, "ab=27 cw=5 x-yz=-99"); + tt_str_op(res,OP_EQ, "ab=27 cw=5 x-yz=-99"); tor_free(res);

res = dirvote_compute_params(votes, 12, 6); - tt_str_op(res,==, ""); + tt_str_op(res,OP_EQ, ""); tor_free(res);

smartlist_add(votes, &vote3);

res = dirvote_compute_params(votes, 12, 3); - tt_str_op(res,==, "ab=27 abcd=20 cw=50 x-yz=-9"); + tt_str_op(res,OP_EQ, "ab=27 abcd=20 cw=50 x-yz=-9"); tor_free(res);

res = dirvote_compute_params(votes, 12, 5); - tt_str_op(res,==, "cw=50 x-yz=-9"); + tt_str_op(res,OP_EQ, "cw=50 x-yz=-9"); tor_free(res);

res = dirvote_compute_params(votes, 12, 9); - tt_str_op(res,==, "cw=50 x-yz=-9"); + tt_str_op(res,OP_EQ, "cw=50 x-yz=-9"); tor_free(res);

smartlist_add(votes, &vote4);

res = dirvote_compute_params(votes, 12, 4); - tt_str_op(res,==, "ab=90 abcd=20 cw=50 x-yz=-9"); + tt_str_op(res,OP_EQ, "ab=90 abcd=20 cw=50 x-yz=-9"); tor_free(res);

res = dirvote_compute_params(votes, 12, 5); - tt_str_op(res,==, "ab=90 abcd=20 cw=50 x-yz=-9"); + tt_str_op(res,OP_EQ, "ab=90 abcd=20 cw=50 x-yz=-9"); tor_free(res);

/* Test that the special-cased "at least three dirauths voted for * this param" logic works as expected. */ res = dirvote_compute_params(votes, 12, 6); - tt_str_op(res,==, "ab=90 abcd=20 cw=50 x-yz=-9"); + tt_str_op(res,OP_EQ, "ab=90 abcd=20 cw=50 x-yz=-9"); tor_free(res);

res = dirvote_compute_params(votes, 12, 10); - tt_str_op(res,==, "ab=90 abcd=20 cw=50 x-yz=-9"); + tt_str_op(res,OP_EQ, "ab=90 abcd=20 cw=50 x-yz=-9"); tor_free(res);

done: @@ -1324,14 +1324,14 @@ static void test_same_voter(networkstatus_voter_info_t *v1, networkstatus_voter_info_t *v2) { - tt_str_op(v1->nickname,==, v2->nickname); - tt_mem_op(v1->identity_digest,==, v2->identity_digest, DIGEST_LEN); - tt_str_op(v1->address,==, v2->address); - tt_int_op(v1->addr,==, v2->addr); - tt_int_op(v1->dir_port,==, v2->dir_port); - tt_int_op(v1->or_port,==, v2->or_port); - tt_str_op(v1->contact,==, v2->contact); - tt_mem_op(v1->vote_digest,==, v2->vote_digest, DIGEST_LEN); + tt_str_op(v1->nickname,OP_EQ, v2->nickname); + tt_mem_op(v1->identity_digest,OP_EQ, v2->identity_digest, DIGEST_LEN); + tt_str_op(v1->address,OP_EQ, v2->address); + tt_int_op(v1->addr,OP_EQ, v2->addr); + tt_int_op(v1->dir_port,OP_EQ, v2->dir_port); + tt_int_op(v1->or_port,OP_EQ, v2->or_port); + tt_str_op(v1->contact,OP_EQ, v2->contact); + tt_mem_op(v1->vote_digest,OP_EQ, v2->vote_digest, DIGEST_LEN); done: ; } @@ -1541,48 +1541,48 @@ test_vrs_for_v3ns(vote_routerstatus_t *vrs, int voter, time_t now) DIGEST_LEN) && (voter == 1)) { /* Check the first routerstatus. */ - tt_str_op(vrs->version,==, "0.1.2.14"); - tt_int_op(rs->published_on,==, now-1500); - tt_str_op(rs->nickname,==, "router2"); - tt_mem_op(rs->identity_digest,==, + tt_str_op(vrs->version,OP_EQ, "0.1.2.14"); + tt_int_op(rs->published_on,OP_EQ, now-1500); + tt_str_op(rs->nickname,OP_EQ, "router2"); + tt_mem_op(rs->identity_digest,OP_EQ, "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3" "\x3\x3\x3\x3", DIGEST_LEN); - tt_mem_op(rs->descriptor_digest,==, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN); - tt_int_op(rs->addr,==, 0x99008801); - tt_int_op(rs->or_port,==, 443); - tt_int_op(rs->dir_port,==, 8000); + tt_mem_op(rs->descriptor_digest,OP_EQ, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN); + tt_int_op(rs->addr,OP_EQ, 0x99008801); + tt_int_op(rs->or_port,OP_EQ, 443); + tt_int_op(rs->dir_port,OP_EQ, 8000); /* no flags except "running" (16) and "v2dir" (64) */ - tt_u64_op(vrs->flags, ==, U64_LITERAL(80)); + tt_u64_op(vrs->flags, OP_EQ, U64_LITERAL(80)); } else if (tor_memeq(rs->identity_digest, "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5" "\x5\x5\x5\x5", DIGEST_LEN) && (voter == 1 || voter == 2)) { - tt_mem_op(rs->identity_digest,==, + tt_mem_op(rs->identity_digest,OP_EQ, "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5" "\x5\x5\x5\x5", DIGEST_LEN);

if (voter == 1) { /* Check the second routerstatus. */ - tt_str_op(vrs->version,==, "0.2.0.5"); - tt_int_op(rs->published_on,==, now-1000); - tt_str_op(rs->nickname,==, "router1"); + tt_str_op(vrs->version,OP_EQ, "0.2.0.5"); + tt_int_op(rs->published_on,OP_EQ, now-1000); + tt_str_op(rs->nickname,OP_EQ, "router1"); } - tt_mem_op(rs->descriptor_digest,==, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN); - tt_int_op(rs->addr,==, 0x99009901); - tt_int_op(rs->or_port,==, 443); - tt_int_op(rs->dir_port,==, 0); + tt_mem_op(rs->descriptor_digest,OP_EQ, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN); + tt_int_op(rs->addr,OP_EQ, 0x99009901); + tt_int_op(rs->or_port,OP_EQ, 443); + tt_int_op(rs->dir_port,OP_EQ, 0); tor_addr_parse(&addr_ipv6, "[1:2:3::4]"); tt_assert(tor_addr_eq(&rs->ipv6_addr, &addr_ipv6)); - tt_int_op(rs->ipv6_orport,==, 4711); + tt_int_op(rs->ipv6_orport,OP_EQ, 4711); if (voter == 1) { /* all except "authority" (1) and "v2dir" (64) */ - tt_u64_op(vrs->flags, ==, U64_LITERAL(190)); + tt_u64_op(vrs->flags, OP_EQ, U64_LITERAL(190)); } else { /* 1023 - authority(1) - madeofcheese(16) - madeoftin(32) - v2dir(256) */ - tt_u64_op(vrs->flags, ==, U64_LITERAL(718)); + tt_u64_op(vrs->flags, OP_EQ, U64_LITERAL(718)); } } else if (tor_memeq(rs->identity_digest, "\x33\x33\x33\x33\x33\x33\x33\x33\x33\x33" @@ -1614,7 +1614,7 @@ test_consensus_for_v3ns(networkstatus_t *con, time_t now)

tt_assert(con); tt_assert(!con->cert); - tt_int_op(2,==, smartlist_len(con->routerstatus_list)); + tt_int_op(2,OP_EQ, smartlist_len(con->routerstatus_list)); /* There should be two listed routers: one with identity 3, one with * identity 5. */

@@ -1639,10 +1639,10 @@ test_routerstatus_for_v3ns(routerstatus_t *rs, time_t now) "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3" "\x3\x3", DIGEST_LEN)) { - tt_mem_op(rs->identity_digest,==, + tt_mem_op(rs->identity_digest,OP_EQ, "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3", DIGEST_LEN); - tt_mem_op(rs->descriptor_digest,==, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN); + tt_mem_op(rs->descriptor_digest,OP_EQ, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN); tt_assert(!rs->is_authority); tt_assert(!rs->is_exit); tt_assert(!rs->is_fast); @@ -1658,18 +1658,18 @@ test_routerstatus_for_v3ns(routerstatus_t *rs, time_t now) "\x5\x5\x5\x5", DIGEST_LEN)) { /* This one showed up in 3 digests. Twice with ID 'M', once with 'Z'. */ - tt_mem_op(rs->identity_digest,==, + tt_mem_op(rs->identity_digest,OP_EQ, "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5", DIGEST_LEN); - tt_str_op(rs->nickname,==, "router1"); - tt_mem_op(rs->descriptor_digest,==, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN); - tt_int_op(rs->published_on,==, now-1000); - tt_int_op(rs->addr,==, 0x99009901); - tt_int_op(rs->or_port,==, 443); - tt_int_op(rs->dir_port,==, 0); + tt_str_op(rs->nickname,OP_EQ, "router1"); + tt_mem_op(rs->descriptor_digest,OP_EQ, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN); + tt_int_op(rs->published_on,OP_EQ, now-1000); + tt_int_op(rs->addr,OP_EQ, 0x99009901); + tt_int_op(rs->or_port,OP_EQ, 443); + tt_int_op(rs->dir_port,OP_EQ, 0); tor_addr_parse(&addr_ipv6, "[1:2:3::4]"); tt_assert(tor_addr_eq(&rs->ipv6_addr, &addr_ipv6)); - tt_int_op(rs->ipv6_orport,==, 4711); + tt_int_op(rs->ipv6_orport,OP_EQ, 4711); tt_assert(!rs->is_authority); tt_assert(rs->is_exit); tt_assert(rs->is_fast); @@ -1809,29 +1809,29 @@ test_a_networkstatus( tt_assert(v1);

/* Make sure the parsed thing was right. */ - tt_int_op(v1->type,==, NS_TYPE_VOTE); - tt_int_op(v1->published,==, vote->published); - tt_int_op(v1->valid_after,==, vote->valid_after); - tt_int_op(v1->fresh_until,==, vote->fresh_until); - tt_int_op(v1->valid_until,==, vote->valid_until); - tt_int_op(v1->vote_seconds,==, vote->vote_seconds); - tt_int_op(v1->dist_seconds,==, vote->dist_seconds); - tt_str_op(v1->client_versions,==, vote->client_versions); - tt_str_op(v1->server_versions,==, vote->server_versions); + tt_int_op(v1->type,OP_EQ, NS_TYPE_VOTE); + tt_int_op(v1->published,OP_EQ, vote->published); + tt_int_op(v1->valid_after,OP_EQ, vote->valid_after); + tt_int_op(v1->fresh_until,OP_EQ, vote->fresh_until); + tt_int_op(v1->valid_until,OP_EQ, vote->valid_until); + tt_int_op(v1->vote_seconds,OP_EQ, vote->vote_seconds); + tt_int_op(v1->dist_seconds,OP_EQ, vote->dist_seconds); + tt_str_op(v1->client_versions,OP_EQ, vote->client_versions); + tt_str_op(v1->server_versions,OP_EQ, vote->server_versions); tt_assert(v1->voters && smartlist_len(v1->voters)); voter = smartlist_get(v1->voters, 0); - tt_str_op(voter->nickname,==, "Voter1"); - tt_str_op(voter->address,==, "1.2.3.4"); - tt_int_op(voter->addr,==, 0x01020304); - tt_int_op(voter->dir_port,==, 80); - tt_int_op(voter->or_port,==, 9000); - tt_str_op(voter->contact,==, "voter@example.com"); + tt_str_op(voter->nickname,OP_EQ, "Voter1"); + tt_str_op(voter->address,OP_EQ, "1.2.3.4"); + tt_int_op(voter->addr,OP_EQ, 0x01020304); + tt_int_op(voter->dir_port,OP_EQ, 80); + tt_int_op(voter->or_port,OP_EQ, 9000); + tt_str_op(voter->contact,OP_EQ, "voter@example.com"); tt_assert(v1->cert); tt_assert(!crypto_pk_cmp_keys(sign_skey_1, v1->cert->signing_key)); cp = smartlist_join_strings(v1->known_flags, ":", 0, NULL); - tt_str_op(cp,==, "Authority:Exit:Fast:Guard:Running:Stable:V2Dir:Valid"); + tt_str_op(cp,OP_EQ, "Authority:Exit:Fast:Guard:Running:Stable:V2Dir:Valid"); tor_free(cp); - tt_int_op(smartlist_len(v1->routerstatus_list),==, n_vrs); + tt_int_op(smartlist_len(v1->routerstatus_list),OP_EQ, n_vrs);

if (vote_tweaks) params_tweaked += vote_tweaks(v1, 1, now);

@@ -1876,7 +1876,7 @@ test_a_networkstatus(

/* Check that flags come out right.*/ cp = smartlist_join_strings(v2->known_flags, ":", 0, NULL); - tt_str_op(cp,==, "Authority:Exit:Fast:Guard:MadeOfCheese:MadeOfTin:" + tt_str_op(cp,OP_EQ, "Authority:Exit:Fast:Guard:MadeOfCheese:MadeOfTin:" "Running:Stable:V2Dir:Valid"); tor_free(cp);

@@ -1945,30 +1945,30 @@ test_a_networkstatus( con_md = networkstatus_parse_vote_from_string(consensus_text_md, NULL, NS_TYPE_CONSENSUS); tt_assert(con_md); - tt_int_op(con_md->flavor,==, FLAV_MICRODESC); + tt_int_op(con_md->flavor,OP_EQ, FLAV_MICRODESC);

/* Check consensus contents. */ tt_assert(con->type == NS_TYPE_CONSENSUS); - tt_int_op(con->published,==, 0); /* this field only appears in votes. */ - tt_int_op(con->valid_after,==, now+1000); - tt_int_op(con->fresh_until,==, now+2003); /* median */ - tt_int_op(con->valid_until,==, now+3000); - tt_int_op(con->vote_seconds,==, 100); - tt_int_op(con->dist_seconds,==, 250); /* median */ - tt_str_op(con->client_versions,==, "0.1.2.14"); - tt_str_op(con->server_versions,==, "0.1.2.15,0.1.2.16"); + tt_int_op(con->published,OP_EQ, 0); /* this field only appears in votes. */ + tt_int_op(con->valid_after,OP_EQ, now+1000); + tt_int_op(con->fresh_until,OP_EQ, now+2003); /* median */ + tt_int_op(con->valid_until,OP_EQ, now+3000); + tt_int_op(con->vote_seconds,OP_EQ, 100); + tt_int_op(con->dist_seconds,OP_EQ, 250); /* median */ + tt_str_op(con->client_versions,OP_EQ, "0.1.2.14"); + tt_str_op(con->server_versions,OP_EQ, "0.1.2.15,0.1.2.16"); cp = smartlist_join_strings(v2->known_flags, ":", 0, NULL); - tt_str_op(cp,==, "Authority:Exit:Fast:Guard:MadeOfCheese:MadeOfTin:" + tt_str_op(cp,OP_EQ, "Authority:Exit:Fast:Guard:MadeOfCheese:MadeOfTin:" "Running:Stable:V2Dir:Valid"); tor_free(cp); if (!params_tweaked) { /* Skip this one if vote_tweaks() messed with the param lists */ cp = smartlist_join_strings(con->net_params, ":", 0, NULL); - tt_str_op(cp,==, "circuitwindow=80:foo=660"); + tt_str_op(cp,OP_EQ, "circuitwindow=80:foo=660"); tor_free(cp); }

- tt_int_op(4,==, smartlist_len(con->voters)); /*3 voters, 1 legacy key.*/ + tt_int_op(4,OP_EQ, smartlist_len(con->voters)); /*3 voters, 1 legacy key.*/ /* The voter id digests should be in this order. */ tt_assert(memcmp(cert2->cache_info.identity_digest, cert1->cache_info.identity_digest,DIGEST_LEN)<0); @@ -1994,10 +1994,10 @@ test_a_networkstatus( /* Check signatures. the first voter is a pseudo-entry with a legacy key. * The second one hasn't signed. The fourth one has signed: validate it. */ voter = smartlist_get(con->voters, 1); - tt_int_op(smartlist_len(voter->sigs),==, 0); + tt_int_op(smartlist_len(voter->sigs),OP_EQ, 0);

voter = smartlist_get(con->voters, 3); - tt_int_op(smartlist_len(voter->sigs),==, 1); + tt_int_op(smartlist_len(voter->sigs),OP_EQ, 1); sig = smartlist_get(voter->sigs, 0); tt_assert(sig->signature); tt_assert(!sig->good_signature); @@ -2047,11 +2047,11 @@ test_a_networkstatus( tt_assert(con_md3);

/* All three should have the same digest. */ - tt_mem_op(&con->digests,==, &con2->digests, sizeof(digests_t)); - tt_mem_op(&con->digests,==, &con3->digests, sizeof(digests_t)); + tt_mem_op(&con->digests,OP_EQ, &con2->digests, sizeof(digests_t)); + tt_mem_op(&con->digests,OP_EQ, &con3->digests, sizeof(digests_t));

- tt_mem_op(&con_md->digests,==, &con_md2->digests, sizeof(digests_t)); - tt_mem_op(&con_md->digests,==, &con_md3->digests, sizeof(digests_t)); + tt_mem_op(&con_md->digests,OP_EQ, &con_md2->digests, sizeof(digests_t)); + tt_mem_op(&con_md->digests,OP_EQ, &con_md3->digests, sizeof(digests_t));

/* Extract a detached signature from con3. */ detached_text1 = get_detached_sigs(con3, con_md3); @@ -2061,44 +2061,44 @@ test_a_networkstatus( tt_assert(dsig1);

/* Are parsed values as expected? */ - tt_int_op(dsig1->valid_after,==, con3->valid_after); - tt_int_op(dsig1->fresh_until,==, con3->fresh_until); - tt_int_op(dsig1->valid_until,==, con3->valid_until); + tt_int_op(dsig1->valid_after,OP_EQ, con3->valid_after); + tt_int_op(dsig1->fresh_until,OP_EQ, con3->fresh_until); + tt_int_op(dsig1->valid_until,OP_EQ, con3->valid_until); { digests_t *dsig_digests = strmap_get(dsig1->digests, "ns"); tt_assert(dsig_digests); - tt_mem_op(dsig_digests->d[DIGEST_SHA1],==, con3->digests.d[DIGEST_SHA1], + tt_mem_op(dsig_digests->d[DIGEST_SHA1],OP_EQ, con3->digests.d[DIGEST_SHA1], DIGEST_LEN); dsig_digests = strmap_get(dsig1->digests, "microdesc"); tt_assert(dsig_digests); - tt_mem_op(dsig_digests->d[DIGEST_SHA256],==, + tt_mem_op(dsig_digests->d[DIGEST_SHA256],OP_EQ, con_md3->digests.d[DIGEST_SHA256], DIGEST256_LEN); } { smartlist_t *dsig_signatures = strmap_get(dsig1->signatures, "ns"); tt_assert(dsig_signatures); - tt_int_op(1,==, smartlist_len(dsig_signatures)); + tt_int_op(1,OP_EQ, smartlist_len(dsig_signatures)); sig = smartlist_get(dsig_signatures, 0); - tt_mem_op(sig->identity_digest,==, cert1->cache_info.identity_digest, + tt_mem_op(sig->identity_digest,OP_EQ, cert1->cache_info.identity_digest, DIGEST_LEN); - tt_int_op(sig->alg,==, DIGEST_SHA1); + tt_int_op(sig->alg,OP_EQ, DIGEST_SHA1);

dsig_signatures = strmap_get(dsig1->signatures, "microdesc"); tt_assert(dsig_signatures); - tt_int_op(1,==, smartlist_len(dsig_signatures)); + tt_int_op(1,OP_EQ, smartlist_len(dsig_signatures)); sig = smartlist_get(dsig_signatures, 0); - tt_mem_op(sig->identity_digest,==, cert1->cache_info.identity_digest, + tt_mem_op(sig->identity_digest,OP_EQ, cert1->cache_info.identity_digest, DIGEST_LEN); - tt_int_op(sig->alg,==, DIGEST_SHA256); + tt_int_op(sig->alg,OP_EQ, DIGEST_SHA256); }

/* Try adding it to con2. */ detached_text2 = get_detached_sigs(con2,con_md2); - tt_int_op(1,==, networkstatus_add_detached_signatures(con2, dsig1, "test", + tt_int_op(1,OP_EQ, networkstatus_add_detached_signatures(con2, dsig1, "test", LOG_INFO, &msg)); tor_free(detached_text2); - tt_int_op(1,==, + tt_int_op(1,OP_EQ, networkstatus_add_detached_signatures(con_md2, dsig1, "test", LOG_INFO, &msg)); tor_free(detached_text2); @@ -2114,18 +2114,18 @@ test_a_networkstatus( printf("%s\n", hd); }); */ - tt_int_op(2,==, + tt_int_op(2,OP_EQ, smartlist_len((smartlist_t*)strmap_get(dsig2->signatures, "ns"))); - tt_int_op(2,==, + tt_int_op(2,OP_EQ, smartlist_len((smartlist_t*)strmap_get(dsig2->signatures, "microdesc")));

/* Try adding to con2 twice; verify that nothing changes. */ - tt_int_op(0,==, networkstatus_add_detached_signatures(con2, dsig1, "test", + tt_int_op(0,OP_EQ, networkstatus_add_detached_signatures(con2, dsig1, "test", LOG_INFO, &msg));

/* Add to con. */ - tt_int_op(2,==, networkstatus_add_detached_signatures(con, dsig2, "test", + tt_int_op(2,OP_EQ, networkstatus_add_detached_signatures(con, dsig2, "test", LOG_INFO, &msg)); /* Check signatures */ voter = smartlist_get(con->voters, 1); @@ -2229,7 +2229,7 @@ test_dir_scale_bw(void *testdata)

scale_array_elements_to_u64(vals, 8, &total);

- tt_int_op((int)total, ==, 48); + tt_int_op((int)total, OP_EQ, 48); total = 0; for (i=0; i<8; ++i) { total += vals[i].u64; @@ -2240,7 +2240,7 @@ test_dir_scale_bw(void *testdata) for (i=0; i<8; ++i) { /* vals[2].u64 is the scaled value of 1.0 */ double ratio = ((double)vals[i].u64) / vals[2].u64; - tt_double_op(fabs(ratio - v[i]), <, .00001); + tt_double_op(fabs(ratio - v[i]), OP_LT, .00001); }

/* test handling of no entries */ @@ -2291,11 +2291,11 @@ test_dir_random_weighted(void *testdata) inp[i].u64 = vals[i]; total += vals[i]; } - tt_u64_op(total, ==, 45); + tt_u64_op(total, OP_EQ, 45); for (i=0; i<n; ++i) { choice = choose_array_element_by_weight(inp, 10); - tt_int_op(choice, >=, 0); - tt_int_op(choice, <, 10); + tt_int_op(choice, OP_GE, 0); + tt_int_op(choice, OP_LT, 10); histogram[choice]++; }

@@ -2308,7 +2308,7 @@ test_dir_random_weighted(void *testdata) if (expected) frac_diff = (histogram[i] - expected) / ((double)expected); else - tt_int_op(histogram[i], ==, 0); + tt_int_op(histogram[i], OP_EQ, 0);

sq = frac_diff * frac_diff; if (sq > max_sq_error) @@ -2316,12 +2316,12 @@ test_dir_random_weighted(void *testdata) } /* It should almost always be much much less than this. If you want to * figure out the odds, please feel free. */ - tt_double_op(max_sq_error, <, .05); + tt_double_op(max_sq_error, OP_LT, .05);

/* Now try a singleton; do we choose it? */ for (i = 0; i < 100; ++i) { choice = choose_array_element_by_weight(inp, 1); - tt_int_op(choice, ==, 0); + tt_int_op(choice, OP_EQ, 0); }

/* Now try an array of zeros. We should choose randomly. */ @@ -2330,8 +2330,8 @@ test_dir_random_weighted(void *testdata) inp[i].u64 = 0; for (i = 0; i < n; ++i) { choice = choose_array_element_by_weight(inp, 5); - tt_int_op(choice, >=, 0); - tt_int_op(choice, <, 5); + tt_int_op(choice, OP_GE, 0); + tt_int_op(choice, OP_LT, 5); histogram[choice]++; } /* Now see if we chose things about frequently enough. */ @@ -2347,7 +2347,7 @@ test_dir_random_weighted(void *testdata) } /* It should almost always be much much less than this. If you want to * figure out the odds, please feel free. */ - tt_double_op(max_sq_error, <, .05); + tt_double_op(max_sq_error, OP_LT, .05); done: ; } @@ -2546,21 +2546,21 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now) * Check the first routerstatus - measured bandwidth below the clip * cutoff. */ - tt_str_op(vrs->version,==, "0.1.2.14"); - tt_int_op(rs->published_on,==, now-1500); - tt_str_op(rs->nickname,==, "router2"); - tt_mem_op(rs->identity_digest,==, + tt_str_op(vrs->version,OP_EQ, "0.1.2.14"); + tt_int_op(rs->published_on,OP_EQ, now-1500); + tt_str_op(rs->nickname,OP_EQ, "router2"); + tt_mem_op(rs->identity_digest,OP_EQ, "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3" "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3", DIGEST_LEN); - tt_mem_op(rs->descriptor_digest,==, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN); - tt_int_op(rs->addr,==, 0x99008801); - tt_int_op(rs->or_port,==, 443); - tt_int_op(rs->dir_port,==, 8000); + tt_mem_op(rs->descriptor_digest,OP_EQ, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN); + tt_int_op(rs->addr,OP_EQ, 0x99008801); + tt_int_op(rs->or_port,OP_EQ, 443); + tt_int_op(rs->dir_port,OP_EQ, 8000); tt_assert(rs->has_bandwidth); tt_assert(vrs->has_measured_bw); - tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb / 2); - tt_int_op(vrs->measured_bw_kb,==, max_unmeasured_bw_kb / 2); + tt_int_op(rs->bandwidth_kb,OP_EQ, max_unmeasured_bw_kb / 2); + tt_int_op(vrs->measured_bw_kb,OP_EQ, max_unmeasured_bw_kb / 2); } else if (tor_memeq(rs->identity_digest, "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5" "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5", @@ -2570,24 +2570,24 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now) * Check the second routerstatus - measured bandwidth above the clip * cutoff. */ - tt_str_op(vrs->version,==, "0.2.0.5"); - tt_int_op(rs->published_on,==, now-1000); - tt_str_op(rs->nickname,==, "router1"); - tt_mem_op(rs->identity_digest,==, + tt_str_op(vrs->version,OP_EQ, "0.2.0.5"); + tt_int_op(rs->published_on,OP_EQ, now-1000); + tt_str_op(rs->nickname,OP_EQ, "router1"); + tt_mem_op(rs->identity_digest,OP_EQ, "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5" "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5", DIGEST_LEN); - tt_mem_op(rs->descriptor_digest,==, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN); - tt_int_op(rs->addr,==, 0x99009901); - tt_int_op(rs->or_port,==, 443); - tt_int_op(rs->dir_port,==, 0); + tt_mem_op(rs->descriptor_digest,OP_EQ, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN); + tt_int_op(rs->addr,OP_EQ, 0x99009901); + tt_int_op(rs->or_port,OP_EQ, 443); + tt_int_op(rs->dir_port,OP_EQ, 0); tor_addr_parse(&addr_ipv6, "[1:2:3::4]"); tt_assert(tor_addr_eq(&rs->ipv6_addr, &addr_ipv6)); - tt_int_op(rs->ipv6_orport,==, 4711); + tt_int_op(rs->ipv6_orport,OP_EQ, 4711); tt_assert(rs->has_bandwidth); tt_assert(vrs->has_measured_bw); - tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb * 2); - tt_int_op(vrs->measured_bw_kb,==, max_unmeasured_bw_kb * 2); + tt_int_op(rs->bandwidth_kb,OP_EQ, max_unmeasured_bw_kb * 2); + tt_int_op(vrs->measured_bw_kb,OP_EQ, max_unmeasured_bw_kb * 2); } else if (tor_memeq(rs->identity_digest, "\x33\x33\x33\x33\x33\x33\x33\x33\x33\x33" "\x33\x33\x33\x33\x33\x33\x33\x33\x33\x33", @@ -2599,8 +2599,8 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now) */ tt_assert(rs->has_bandwidth); tt_assert(!(vrs->has_measured_bw)); - tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb * 2); - tt_int_op(vrs->measured_bw_kb,==, 0); + tt_int_op(rs->bandwidth_kb,OP_EQ, max_unmeasured_bw_kb * 2); + tt_int_op(vrs->measured_bw_kb,OP_EQ, 0); } else if (tor_memeq(rs->identity_digest, "\x34\x34\x34\x34\x34\x34\x34\x34\x34\x34" "\x34\x34\x34\x34\x34\x34\x34\x34\x34\x34", @@ -2611,8 +2611,8 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now) */ tt_assert(rs->has_bandwidth); tt_assert(!(vrs->has_measured_bw)); - tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb / 2); - tt_int_op(vrs->measured_bw_kb,==, 0); + tt_int_op(rs->bandwidth_kb,OP_EQ, max_unmeasured_bw_kb / 2); + tt_int_op(vrs->measured_bw_kb,OP_EQ, 0); } else { tt_assert(0); } @@ -2633,7 +2633,7 @@ test_consensus_for_umbw(networkstatus_t *con, time_t now) tt_assert(!con->cert); // tt_assert(con->consensus_method >= MIN_METHOD_TO_CLIP_UNMEASURED_BW_KB); tt_assert(con->consensus_method >= 16); - tt_int_op(4,==, smartlist_len(con->routerstatus_list)); + tt_int_op(4,OP_EQ, smartlist_len(con->routerstatus_list)); /* There should be four listed routers; all voters saw the same in this */

done: @@ -2657,11 +2657,11 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now) "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3" "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3", DIGEST_LEN)) { - tt_mem_op(rs->identity_digest,==, + tt_mem_op(rs->identity_digest,OP_EQ, "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3" "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3", DIGEST_LEN); - tt_mem_op(rs->descriptor_digest,==, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN); + tt_mem_op(rs->descriptor_digest,OP_EQ, "NNNNNNNNNNNNNNNNNNNN", DIGEST_LEN); tt_assert(!rs->is_authority); tt_assert(!rs->is_exit); tt_assert(!rs->is_fast); @@ -2673,26 +2673,26 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now) tt_assert(!rs->is_named); /* This one should have measured bandwidth below the clip cutoff */ tt_assert(rs->has_bandwidth); - tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb / 2); + tt_int_op(rs->bandwidth_kb,OP_EQ, max_unmeasured_bw_kb / 2); tt_assert(!(rs->bw_is_unmeasured)); } else if (tor_memeq(rs->identity_digest, "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5" "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5", DIGEST_LEN)) { /* This one showed up in 3 digests. Twice with ID 'M', once with 'Z'. */ - tt_mem_op(rs->identity_digest,==, + tt_mem_op(rs->identity_digest,OP_EQ, "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5" "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5", DIGEST_LEN); - tt_str_op(rs->nickname,==, "router1"); - tt_mem_op(rs->descriptor_digest,==, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN); - tt_int_op(rs->published_on,==, now-1000); - tt_int_op(rs->addr,==, 0x99009901); - tt_int_op(rs->or_port,==, 443); - tt_int_op(rs->dir_port,==, 0); + tt_str_op(rs->nickname,OP_EQ, "router1"); + tt_mem_op(rs->descriptor_digest,OP_EQ, "MMMMMMMMMMMMMMMMMMMM", DIGEST_LEN); + tt_int_op(rs->published_on,OP_EQ, now-1000); + tt_int_op(rs->addr,OP_EQ, 0x99009901); + tt_int_op(rs->or_port,OP_EQ, 443); + tt_int_op(rs->dir_port,OP_EQ, 0); tor_addr_parse(&addr_ipv6, "[1:2:3::4]"); tt_assert(tor_addr_eq(&rs->ipv6_addr, &addr_ipv6)); - tt_int_op(rs->ipv6_orport,==, 4711); + tt_int_op(rs->ipv6_orport,OP_EQ, 4711); tt_assert(!rs->is_authority); tt_assert(rs->is_exit); tt_assert(rs->is_fast); @@ -2703,7 +2703,7 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now) tt_assert(!rs->is_named); /* This one should have measured bandwidth above the clip cutoff */ tt_assert(rs->has_bandwidth); - tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb * 2); + tt_int_op(rs->bandwidth_kb,OP_EQ, max_unmeasured_bw_kb * 2); tt_assert(!(rs->bw_is_unmeasured)); } else if (tor_memeq(rs->identity_digest, "\x33\x33\x33\x33\x33\x33\x33\x33\x33\x33" @@ -2714,7 +2714,7 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now) * and so should be clipped */ tt_assert(rs->has_bandwidth); - tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb); + tt_int_op(rs->bandwidth_kb,OP_EQ, max_unmeasured_bw_kb); tt_assert(rs->bw_is_unmeasured); } else if (tor_memeq(rs->identity_digest, "\x34\x34\x34\x34\x34\x34\x34\x34\x34\x34" @@ -2725,7 +2725,7 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now) * and so should not be clipped */ tt_assert(rs->has_bandwidth); - tt_int_op(rs->bandwidth_kb,==, max_unmeasured_bw_kb / 2); + tt_int_op(rs->bandwidth_kb,OP_EQ, max_unmeasured_bw_kb / 2); tt_assert(rs->bw_is_unmeasured); } else { /* Weren't expecting this... */ @@ -2801,7 +2801,7 @@ test_dir_fmt_control_ns(void *arg)

s = networkstatus_getinfo_helper_single(&rs); tt_assert(s); - tt_str_op(s, ==, + tt_str_op(s, OP_EQ, "r TetsuoMilk U3RhdGVseSwgcGx1bXAgQnVjayA " "TXVsbGlnYW4gY2FtZSB1cCBmcm8 2013-04-02 17:53:18 " "32.48.64.80 9001 9002\n" @@ -2824,16 +2824,16 @@ test_dir_http_handling(void *args) "Host: example.com\r\n" "User-Agent: Mozilla/5.0 (Windows;" " U; Windows NT 6.1; en-US; rv:1.9.1.5)\r\n", - &url),==, 0); - tt_str_op(url,==, "/tor/a/b/c.txt"); + &url),OP_EQ, 0); + tt_str_op(url,OP_EQ, "/tor/a/b/c.txt"); tor_free(url);

- tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.0\r\n", &url),==, 0); - tt_str_op(url,==, "/tor/a/b/c.txt"); + tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.0\r\n", &url),OP_EQ, 0); + tt_str_op(url,OP_EQ, "/tor/a/b/c.txt"); tor_free(url);

- tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.600\r\n", &url),==, 0); - tt_str_op(url,==, "/tor/a/b/c.txt"); + tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.600\r\n", &url),OP_EQ, 0); + tt_str_op(url,OP_EQ, "/tor/a/b/c.txt"); tor_free(url);

/* Should prepend '/tor/' to url if required */ @@ -2841,8 +2841,8 @@ test_dir_http_handling(void *args) "Host: example.com\r\n" "User-Agent: Mozilla/5.0 (Windows;" " U; Windows NT 6.1; en-US; rv:1.9.1.5)\r\n", - &url),==, 0); - tt_str_op(url,==, "/tor/a/b/c.txt"); + &url),OP_EQ, 0); + tt_str_op(url,OP_EQ, "/tor/a/b/c.txt"); tor_free(url);

/* Bad headers -- no HTTP/1.x*/ @@ -2850,7 +2850,7 @@ test_dir_http_handling(void *args) "Host: example.com\r\n" "User-Agent: Mozilla/5.0 (Windows;" " U; Windows NT 6.1; en-US; rv:1.9.1.5)\r\n", - &url),==, -1); + &url),OP_EQ, -1); tt_assert(!url);

/* Bad headers */ @@ -2858,22 +2858,22 @@ test_dir_http_handling(void *args) "Host: example.com\r\n" "User-Agent: Mozilla/5.0 (Windows;" " U; Windows NT 6.1; en-US; rv:1.9.1.5)\r\n", - &url),==, -1); + &url),OP_EQ, -1); tt_assert(!url);

- tt_int_op(parse_http_url("GET /tor/a/b/c.txt", &url),==, -1); + tt_int_op(parse_http_url("GET /tor/a/b/c.txt", &url),OP_EQ, -1); tt_assert(!url);

- tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.1", &url),==, -1); + tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.1", &url),OP_EQ, -1); tt_assert(!url);

- tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.1x\r\n", &url),==, -1); + tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.1x\r\n", &url),OP_EQ, -1); tt_assert(!url);

- tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.", &url),==, -1); + tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.", &url),OP_EQ, -1); tt_assert(!url);

- tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.\r", &url),==, -1); + tt_int_op(parse_http_url("GET /tor/a/b/c.txt HTTP/1.\r", &url),OP_EQ, -1); tt_assert(!url);

done: diff --git a/src/test/test_entrynodes.c b/src/test/test_entrynodes.c index bddc0f1..eaf2e2d 100644 --- a/src/test/test_entrynodes.c +++ b/src/test/test_entrynodes.c @@ -71,15 +71,15 @@ setup_fake_routerlist(void) retval = router_load_routers_from_string(TEST_DESCRIPTORS, NULL, SAVED_IN_JOURNAL, NULL, 0, NULL); - tt_int_op(retval, ==, NUMBER_OF_DESCRIPTORS); + tt_int_op(retval, OP_EQ, NUMBER_OF_DESCRIPTORS);

/* Sanity checking of routerlist and nodelist. */ our_routerlist = router_get_routerlist(); - tt_int_op(smartlist_len(our_routerlist->routers), ==, NUMBER_OF_DESCRIPTORS); + tt_int_op(smartlist_len(our_routerlist->routers), OP_EQ, NUMBER_OF_DESCRIPTORS); routerlist_assert_ok(our_routerlist);

our_nodelist = nodelist_get_list(); - tt_int_op(smartlist_len(our_nodelist), ==, NUMBER_OF_DESCRIPTORS); + tt_int_op(smartlist_len(our_nodelist), OP_EQ, NUMBER_OF_DESCRIPTORS);

/* Mark all routers as non-guards but up and running! */ SMARTLIST_FOREACH_BEGIN(our_nodelist, node_t *, node) { @@ -163,7 +163,7 @@ test_choose_random_entry_one_possible_guard(void *arg)

/* Pick an entry. Make sure we pick the node we marked as guard. */ chosen_entry = choose_random_entry(NULL); - tt_ptr_op(chosen_entry, ==, the_guard); + tt_ptr_op(chosen_entry, OP_EQ, the_guard);

done: ; @@ -189,14 +189,14 @@ populate_live_entry_guards_test_helper(int num_needed)

/* Set NumEntryGuards to the provided number. */ options->NumEntryGuards = num_needed; - tt_int_op(num_needed, ==, decide_num_guards(options, 0)); + tt_int_op(num_needed, OP_EQ, decide_num_guards(options, 0));

/* The global entry guards smartlist should be empty now. */ - tt_int_op(smartlist_len(all_entry_guards), ==, 0); + tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 0);

/* Walk the nodelist and add all nodes as entry guards. */ our_nodelist = nodelist_get_list(); - tt_int_op(smartlist_len(our_nodelist), ==, NUMBER_OF_DESCRIPTORS); + tt_int_op(smartlist_len(our_nodelist), OP_EQ, NUMBER_OF_DESCRIPTORS);

SMARTLIST_FOREACH_BEGIN(our_nodelist, const node_t *, node) { const node_t *node_tmp; @@ -205,20 +205,20 @@ populate_live_entry_guards_test_helper(int num_needed) } SMARTLIST_FOREACH_END(node);

/* Make sure the nodes were added as entry guards. */ - tt_int_op(smartlist_len(all_entry_guards), ==, NUMBER_OF_DESCRIPTORS); + tt_int_op(smartlist_len(all_entry_guards), OP_EQ, NUMBER_OF_DESCRIPTORS);

/* Ensure that all the possible entry guards are enough to satisfy us. */ - tt_int_op(smartlist_len(all_entry_guards), >=, num_needed); + tt_int_op(smartlist_len(all_entry_guards), OP_GE, num_needed);

/* Walk the entry guard list for some sanity checking */ SMARTLIST_FOREACH_BEGIN(all_entry_guards, const entry_guard_t *, entry) { /* Since we called add_an_entry_guard() with 'for_discovery' being False, all guards should have made_contact enabled. */ - tt_int_op(entry->made_contact, ==, 1); + tt_int_op(entry->made_contact, OP_EQ, 1);

/* Since we don't have a routerstatus, all of the entry guards are not directory servers. */ - tt_int_op(entry->is_dir_cache, ==, 0); + tt_int_op(entry->is_dir_cache, OP_EQ, 0); } SMARTLIST_FOREACH_END(entry);

/* First, try to get some fast guards. This should fail. */ @@ -228,8 +228,8 @@ populate_live_entry_guards_test_helper(int num_needed) NO_DIRINFO, /* Don't care about DIRINFO*/ 0, 0, 1); /* We want fast guard! */ - tt_int_op(retval, ==, 0); - tt_int_op(smartlist_len(live_entry_guards), ==, 0); + tt_int_op(retval, OP_EQ, 0); + tt_int_op(smartlist_len(live_entry_guards), OP_EQ, 0);

/* Now try to get some stable guards. This should fail too. */ retval = populate_live_entry_guards(live_entry_guards, @@ -239,8 +239,8 @@ populate_live_entry_guards_test_helper(int num_needed) 0, 1, /* We want stable guard! */ 0); - tt_int_op(retval, ==, 0); - tt_int_op(smartlist_len(live_entry_guards), ==, 0); + tt_int_op(retval, OP_EQ, 0); + tt_int_op(smartlist_len(live_entry_guards), OP_EQ, 0);

/* Now try to get any guard we can find. This should succeed. */ retval = populate_live_entry_guards(live_entry_guards, @@ -253,8 +253,8 @@ populate_live_entry_guards_test_helper(int num_needed) should have added 'num_needed' of them to live_entry_guards. 'retval' should be 1 since we now have enough live entry guards to pick one. */ - tt_int_op(retval, ==, 1); - tt_int_op(smartlist_len(live_entry_guards), ==, num_needed); + tt_int_op(retval, OP_EQ, 1); + tt_int_op(smartlist_len(live_entry_guards), OP_EQ, num_needed);

done: smartlist_free(live_entry_guards); @@ -361,7 +361,7 @@ test_entry_guards_parse_state_simple(void *arg) (void) arg;

/* The global entry guards smartlist should be empty now. */ - tt_int_op(smartlist_len(all_entry_guards), ==, 0); + tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 0);

{ /* Prepare the state entry */

@@ -387,34 +387,34 @@ test_entry_guards_parse_state_simple(void *arg)

/* Parse state */ retval = entry_guards_parse_state(state, 1, &msg); - tt_int_op(retval, >=, 0); + tt_int_op(retval, OP_GE, 0);

/* Test that the guard was registered. We need to re-get the entry guard list since its pointer was overwritten in entry_guards_parse_state(). */ all_entry_guards = get_entry_guards(); - tt_int_op(smartlist_len(all_entry_guards), ==, 1); + tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 1);

{ /* Test the entry guard structure */ char hex_digest[1024]; char str_time[1024];

const entry_guard_t *e = smartlist_get(all_entry_guards, 0); - tt_str_op(e->nickname, ==, nickname); /* Verify nickname */ + tt_str_op(e->nickname, OP_EQ, nickname); /* Verify nickname */

base16_encode(hex_digest, sizeof(hex_digest), e->identity, DIGEST_LEN); - tt_str_op(hex_digest, ==, fpr); /* Verify fingerprint */ + tt_str_op(hex_digest, OP_EQ, fpr); /* Verify fingerprint */

tt_assert(e->is_dir_cache); /* Verify dirness */

- tt_str_op(e->chosen_by_version, ==, tor_version); /* Verify tor version */ + tt_str_op(e->chosen_by_version, OP_EQ, tor_version); /* Verify tor version */

tt_assert(e->made_contact); /* All saved guards have been contacted */

tt_assert(e->bad_since); /* Verify bad_since timestamp */ format_iso_time(str_time, e->bad_since); - tt_str_op(str_time, ==, unlisted_since); + tt_str_op(str_time, OP_EQ, unlisted_since);

/* The rest should be unset */ tt_assert(!e->unreachable_since); @@ -456,7 +456,7 @@ test_entry_guards_parse_state_pathbias(void *arg) (void) arg;

/* The global entry guards smartlist should be empty now. */ - tt_int_op(smartlist_len(all_entry_guards), ==, 0); + tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 0);

{ /* Prepare the state entry */

@@ -492,11 +492,11 @@ test_entry_guards_parse_state_pathbias(void *arg)

/* Parse state */ retval = entry_guards_parse_state(state, 1, &msg); - tt_int_op(retval, >=, 0); + tt_int_op(retval, OP_GE, 0);

/* Test that the guard was registered */ all_entry_guards = get_entry_guards(); - tt_int_op(smartlist_len(all_entry_guards), ==, 1); + tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 1);

{ /* Test the path bias of this guard */ const entry_guard_t *e = smartlist_get(all_entry_guards, 0); @@ -505,12 +505,12 @@ test_entry_guards_parse_state_pathbias(void *arg) tt_assert(!e->can_retry);

/* XXX tt_double_op doesn't support equality. Cast to int for now. */ - tt_int_op((int)e->circ_attempts, ==, (int)circ_attempts); - tt_int_op((int)e->circ_successes, ==, (int)circ_successes); - tt_int_op((int)e->successful_circuits_closed, ==, (int)successful_closed); - tt_int_op((int)e->timeouts, ==, (int)timeouts); - tt_int_op((int)e->collapsed_circuits, ==, (int)collapsed); - tt_int_op((int)e->unusable_circuits, ==, (int)unusable); + tt_int_op((int)e->circ_attempts, OP_EQ, (int)circ_attempts); + tt_int_op((int)e->circ_successes, OP_EQ, (int)circ_successes); + tt_int_op((int)e->successful_circuits_closed, OP_EQ, (int)successful_closed); + tt_int_op((int)e->timeouts, OP_EQ, (int)timeouts); + tt_int_op((int)e->collapsed_circuits, OP_EQ, (int)collapsed); + tt_int_op((int)e->unusable_circuits, OP_EQ, (int)unusable); }

done: @@ -537,17 +537,17 @@ test_entry_guards_set_from_config(void *arg) retval = routerset_parse(options->EntryNodes, entrynodes_str, "test_entrynodes"); - tt_int_op(retval, >=, 0); + tt_int_op(retval, OP_GE, 0);

/* Read nodes from EntryNodes */ entry_guards_set_from_config(options);

/* Test that only one guard was added. */ - tt_int_op(smartlist_len(all_entry_guards), ==, 1); + tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 1);

/* Make sure it was the guard we specified. */ chosen_entry = choose_random_entry(NULL); - tt_str_op(chosen_entry->ri->nickname, ==, entrynodes_str); + tt_str_op(chosen_entry->ri->nickname, OP_EQ, entrynodes_str);

done: routerset_free(options->EntryNodes); @@ -569,59 +569,59 @@ test_entry_is_time_to_retry(void *arg) test_guard->unreachable_since = now - 1;

retval = entry_is_time_to_retry(test_guard,now); - tt_int_op(retval,==,1); + tt_int_op(retval,OP_EQ,1);

test_guard->unreachable_since = now - (6*60*60 - 1); test_guard->last_attempted = now - (60*60 + 1);

retval = entry_is_time_to_retry(test_guard,now); - tt_int_op(retval,==,1); + tt_int_op(retval,OP_EQ,1);

test_guard->last_attempted = now - (60*60 - 1);

retval = entry_is_time_to_retry(test_guard,now); - tt_int_op(retval,==,0); + tt_int_op(retval,OP_EQ,0);

test_guard->unreachable_since = now - (6*60*60 + 1); test_guard->last_attempted = now - (4*60*60 + 1);

retval = entry_is_time_to_retry(test_guard,now); - tt_int_op(retval,==,1); + tt_int_op(retval,OP_EQ,1);

test_guard->unreachable_since = now - (3*24*60*60 - 1); test_guard->last_attempted = now - (4*60*60 + 1);

retval = entry_is_time_to_retry(test_guard,now); - tt_int_op(retval,==,1); + tt_int_op(retval,OP_EQ,1);

test_guard->unreachable_since = now - (3*24*60*60 + 1); test_guard->last_attempted = now - (18*60*60 + 1);

retval = entry_is_time_to_retry(test_guard,now); - tt_int_op(retval,==,1); + tt_int_op(retval,OP_EQ,1);

test_guard->unreachable_since = now - (7*24*60*60 - 1); test_guard->last_attempted = now - (18*60*60 + 1);

retval = entry_is_time_to_retry(test_guard,now); - tt_int_op(retval,==,1); + tt_int_op(retval,OP_EQ,1);

test_guard->last_attempted = now - (18*60*60 - 1);

retval = entry_is_time_to_retry(test_guard,now); - tt_int_op(retval,==,0); + tt_int_op(retval,OP_EQ,0);

test_guard->unreachable_since = now - (7*24*60*60 + 1); test_guard->last_attempted = now - (36*60*60 + 1);

retval = entry_is_time_to_retry(test_guard,now); - tt_int_op(retval,==,1); + tt_int_op(retval,OP_EQ,1);

test_guard->unreachable_since = now - (7*24*60*60 + 1); test_guard->last_attempted = now - (36*60*60 + 1);

retval = entry_is_time_to_retry(test_guard,now); - tt_int_op(retval,==,1); + tt_int_op(retval,OP_EQ,1);

done: tor_free(test_guard); @@ -641,23 +641,23 @@ test_entry_is_live(void *arg) (void) arg;

/* The global entry guards smartlist should be empty now. */ - tt_int_op(smartlist_len(all_entry_guards), ==, 0); + tt_int_op(smartlist_len(all_entry_guards), OP_EQ, 0);

/* Walk the nodelist and add all nodes as entry guards. */ our_nodelist = nodelist_get_list(); - tt_int_op(smartlist_len(our_nodelist), ==, NUMBER_OF_DESCRIPTORS); + tt_int_op(smartlist_len(our_nodelist), OP_EQ, NUMBER_OF_DESCRIPTORS);

SMARTLIST_FOREACH_BEGIN(our_nodelist, const node_t *, node) { const node_t *node_tmp; node_tmp = add_an_entry_guard(node, 0, 1, 0, 0); tt_assert(node_tmp);

- tt_int_op(node->is_stable, ==, 0); - tt_int_op(node->is_fast, ==, 0); + tt_int_op(node->is_stable, OP_EQ, 0); + tt_int_op(node->is_fast, OP_EQ, 0); } SMARTLIST_FOREACH_END(node);

/* Make sure the nodes were added as entry guards. */ - tt_int_op(smartlist_len(all_entry_guards), ==, NUMBER_OF_DESCRIPTORS); + tt_int_op(smartlist_len(all_entry_guards), OP_EQ, NUMBER_OF_DESCRIPTORS);

/* Now get a random test entry that we will use for this unit test. */ which_node = 3; /* (chosen by fair dice roll) */ @@ -681,12 +681,12 @@ test_entry_is_live(void *arg) /* Don't impose any restrictions on the node. Should succeed. */ test_node = entry_is_live(test_entry, 0, &msg); tt_assert(test_node); - tt_ptr_op(test_node, ==, node_get_by_id(test_entry->identity)); + tt_ptr_op(test_node, OP_EQ, node_get_by_id(test_entry->identity));

/* Require descriptor for this node. It has one so it should succeed. */ test_node = entry_is_live(test_entry, ENTRY_NEED_DESCRIPTOR, &msg); tt_assert(test_node); - tt_ptr_op(test_node, ==, node_get_by_id(test_entry->identity)); + tt_ptr_op(test_node, OP_EQ, node_get_by_id(test_entry->identity));

done: ; /* XXX */ diff --git a/src/test/test_extorport.c b/src/test/test_extorport.c index 4049d6d..c9d8527 100644 --- a/src/test/test_extorport.c +++ b/src/test/test_extorport.c @@ -24,35 +24,35 @@ test_ext_or_id_map(void *arg) (void)arg;

/* pre-initialization */ - tt_ptr_op(NULL, ==, connection_or_get_by_ext_or_id("xxxxxxxxxxxxxxxxxxxx")); + tt_ptr_op(NULL, OP_EQ, connection_or_get_by_ext_or_id("xxxxxxxxxxxxxxxxxxxx"));

c1 = or_connection_new(CONN_TYPE_EXT_OR, AF_INET); c2 = or_connection_new(CONN_TYPE_EXT_OR, AF_INET); c3 = or_connection_new(CONN_TYPE_OR, AF_INET);

- tt_ptr_op(c1->ext_or_conn_id, !=, NULL); - tt_ptr_op(c2->ext_or_conn_id, !=, NULL); - tt_ptr_op(c3->ext_or_conn_id, ==, NULL); + tt_ptr_op(c1->ext_or_conn_id, OP_NE, NULL); + tt_ptr_op(c2->ext_or_conn_id, OP_NE, NULL); + tt_ptr_op(c3->ext_or_conn_id, OP_EQ, NULL);

- tt_ptr_op(c1, ==, connection_or_get_by_ext_or_id(c1->ext_or_conn_id)); - tt_ptr_op(c2, ==, connection_or_get_by_ext_or_id(c2->ext_or_conn_id)); - tt_ptr_op(NULL, ==, connection_or_get_by_ext_or_id("xxxxxxxxxxxxxxxxxxxx")); + tt_ptr_op(c1, OP_EQ, connection_or_get_by_ext_or_id(c1->ext_or_conn_id)); + tt_ptr_op(c2, OP_EQ, connection_or_get_by_ext_or_id(c2->ext_or_conn_id)); + tt_ptr_op(NULL, OP_EQ, connection_or_get_by_ext_or_id("xxxxxxxxxxxxxxxxxxxx"));

idp = tor_memdup(c2->ext_or_conn_id, EXT_OR_CONN_ID_LEN);

/* Give c2 a new ID. */ connection_or_set_ext_or_identifier(c2); - tt_mem_op(idp, !=, c2->ext_or_conn_id, EXT_OR_CONN_ID_LEN); + tt_mem_op(idp, OP_NE, c2->ext_or_conn_id, EXT_OR_CONN_ID_LEN); idp2 = tor_memdup(c2->ext_or_conn_id, EXT_OR_CONN_ID_LEN); tt_assert(!tor_digest_is_zero(idp2));

- tt_ptr_op(NULL, ==, connection_or_get_by_ext_or_id(idp)); - tt_ptr_op(c2, ==, connection_or_get_by_ext_or_id(idp2)); + tt_ptr_op(NULL, OP_EQ, connection_or_get_by_ext_or_id(idp)); + tt_ptr_op(c2, OP_EQ, connection_or_get_by_ext_or_id(idp2));

/* Now remove it. */ connection_or_remove_from_ext_or_id_map(c2); - tt_ptr_op(NULL, ==, connection_or_get_by_ext_or_id(idp)); - tt_ptr_op(NULL, ==, connection_or_get_by_ext_or_id(idp2)); + tt_ptr_op(NULL, OP_EQ, connection_or_get_by_ext_or_id(idp)); + tt_ptr_op(NULL, OP_EQ, connection_or_get_by_ext_or_id(idp2));

done: if (c1) @@ -112,33 +112,33 @@ test_ext_or_write_command(void *arg)

/* Length too long */ tt_int_op(connection_write_ext_or_command(TO_CONN(c1), 100, "X", 100000), - <, 0); + OP_LT, 0);

/* Empty command */ tt_int_op(connection_write_ext_or_command(TO_CONN(c1), 0x99, NULL, 0), - ==, 0); + OP_EQ, 0); cp = buf_get_contents(TO_CONN(c1)->outbuf, &sz); - tt_int_op(sz, ==, 4); - tt_mem_op(cp, ==, "\x00\x99\x00\x00", 4); + tt_int_op(sz, OP_EQ, 4); + tt_mem_op(cp, OP_EQ, "\x00\x99\x00\x00", 4); tor_free(cp);

/* Medium command. */ tt_int_op(connection_write_ext_or_command(TO_CONN(c1), 0x99, - "Wai\0Hello", 9), ==, 0); + "Wai\0Hello", 9), OP_EQ, 0); cp = buf_get_contents(TO_CONN(c1)->outbuf, &sz); - tt_int_op(sz, ==, 13); - tt_mem_op(cp, ==, "\x00\x99\x00\x09Wai\x00Hello", 13); + tt_int_op(sz, OP_EQ, 13); + tt_mem_op(cp, OP_EQ, "\x00\x99\x00\x09Wai\x00Hello", 13); tor_free(cp);

/* Long command */ buf = tor_malloc(65535); memset(buf, 'x', 65535); tt_int_op(connection_write_ext_or_command(TO_CONN(c1), 0xf00d, - buf, 65535), ==, 0); + buf, 65535), OP_EQ, 0); cp = buf_get_contents(TO_CONN(c1)->outbuf, &sz); - tt_int_op(sz, ==, 65539); - tt_mem_op(cp, ==, "\xf0\x0d\xff\xff", 4); - tt_mem_op(cp+4, ==, buf, 65535); + tt_int_op(sz, OP_EQ, 65539); + tt_mem_op(cp, OP_EQ, "\xf0\x0d\xff\xff", 4); + tt_mem_op(cp+4, OP_EQ, buf, 65535); tor_free(cp);

done: @@ -175,7 +175,7 @@ test_ext_or_init_auth(void *arg) tor_free(options->DataDirectory); options->DataDirectory = tor_strdup("foo"); cp = get_ext_or_auth_cookie_file_name(); - tt_str_op(cp, ==, "foo"PATH_SEPARATOR"extended_orport_auth_cookie"); + tt_str_op(cp, OP_EQ, "foo"PATH_SEPARATOR"extended_orport_auth_cookie"); tor_free(cp);

/* Shouldn't be initialized already, or our tests will be a bit @@ -187,30 +187,30 @@ test_ext_or_init_auth(void *arg) fn = get_fname("ext_cookie_file"); options->ExtORPortCookieAuthFile = tor_strdup(fn); cp = get_ext_or_auth_cookie_file_name(); - tt_str_op(cp, ==, fn); + tt_str_op(cp, OP_EQ, fn); tor_free(cp);

/* Test the initialization function with a broken write_bytes_to_file(). See if the problem is handled properly. */ MOCK(write_bytes_to_file, write_bytes_to_file_fail); - tt_int_op(-1, ==, init_ext_or_cookie_authentication(1)); - tt_int_op(ext_or_auth_cookie_is_set, ==, 0); + tt_int_op(-1, OP_EQ, init_ext_or_cookie_authentication(1)); + tt_int_op(ext_or_auth_cookie_is_set, OP_EQ, 0); UNMOCK(write_bytes_to_file);

/* Now do the actual initialization. */ - tt_int_op(0, ==, init_ext_or_cookie_authentication(1)); - tt_int_op(ext_or_auth_cookie_is_set, ==, 1); + tt_int_op(0, OP_EQ, init_ext_or_cookie_authentication(1)); + tt_int_op(ext_or_auth_cookie_is_set, OP_EQ, 1); cp = read_file_to_str(fn, RFTS_BIN, &st); - tt_ptr_op(cp, !=, NULL); - tt_u64_op((uint64_t)st.st_size, ==, 64); - tt_mem_op(cp,==, "! Extended ORPort Auth Cookie !\x0a", 32); - tt_mem_op(cp+32,==, ext_or_auth_cookie, 32); + tt_ptr_op(cp, OP_NE, NULL); + tt_u64_op((uint64_t)st.st_size, OP_EQ, 64); + tt_mem_op(cp,OP_EQ, "! Extended ORPort Auth Cookie !\x0a", 32); + tt_mem_op(cp+32,OP_EQ, ext_or_auth_cookie, 32); memcpy(cookie0, ext_or_auth_cookie, 32); tt_assert(!tor_mem_is_zero((char*)ext_or_auth_cookie, 32));

/* Operation should be idempotent. */ - tt_int_op(0, ==, init_ext_or_cookie_authentication(1)); - tt_mem_op(cookie0,==, ext_or_auth_cookie, 32); + tt_int_op(0, OP_EQ, init_ext_or_cookie_authentication(1)); + tt_mem_op(cookie0,OP_EQ, ext_or_auth_cookie, 32);

done: tor_free(cp); @@ -237,8 +237,8 @@ test_ext_or_cookie_auth(void *arg)

(void)arg;

- tt_int_op(strlen(client_hash_input), ==, 46+32+32); - tt_int_op(strlen(server_hash_input), ==, 46+32+32); + tt_int_op(strlen(client_hash_input), OP_EQ, 46+32+32); + tt_int_op(strlen(server_hash_input), OP_EQ, 46+32+32);

ext_or_auth_cookie = tor_malloc_zero(32); memcpy(ext_or_auth_cookie, "s beside you? When I count, ther", 32); @@ -258,20 +258,20 @@ test_ext_or_cookie_auth(void *arg) */

/* Wrong length */ - tt_int_op(-1, ==, + tt_int_op(-1, OP_EQ, handle_client_auth_nonce(client_nonce, 33, &client_hash, &reply, &reply_len)); - tt_int_op(-1, ==, + tt_int_op(-1, OP_EQ, handle_client_auth_nonce(client_nonce, 31, &client_hash, &reply, &reply_len));

/* Now let's try this for real! */ - tt_int_op(0, ==, + tt_int_op(0, OP_EQ, handle_client_auth_nonce(client_nonce, 32, &client_hash, &reply, &reply_len)); - tt_int_op(reply_len, ==, 64); - tt_ptr_op(reply, !=, NULL); - tt_ptr_op(client_hash, !=, NULL); + tt_int_op(reply_len, OP_EQ, 64); + tt_ptr_op(reply, OP_NE, NULL); + tt_ptr_op(client_hash, OP_NE, NULL); /* Fill in the server nonce into the hash inputs... */ memcpy(server_hash_input+46+32, reply+32, 32); memcpy(client_hash_input+46+32, reply+32, 32); @@ -280,15 +280,15 @@ test_ext_or_cookie_auth(void *arg) 46+32+32); crypto_hmac_sha256(hmac2, (char*)ext_or_auth_cookie, 32, client_hash_input, 46+32+32); - tt_mem_op(hmac1,==, reply, 32); - tt_mem_op(hmac2,==, client_hash, 32); + tt_mem_op(hmac1,OP_EQ, reply, 32); + tt_mem_op(hmac2,OP_EQ, client_hash, 32);

/* Now do it again and make sure that the results are *different* */ - tt_int_op(0, ==, + tt_int_op(0, OP_EQ, handle_client_auth_nonce(client_nonce, 32, &client_hash2, &reply2, &reply_len)); - tt_mem_op(reply2,!=, reply, reply_len); - tt_mem_op(client_hash2,!=, client_hash, 32); + tt_mem_op(reply2,OP_NE, reply, reply_len); + tt_mem_op(client_hash2,OP_NE, client_hash, 32); /* But that this one checks out too. */ memcpy(server_hash_input+46+32, reply2+32, 32); memcpy(client_hash_input+46+32, reply2+32, 32); @@ -297,8 +297,8 @@ test_ext_or_cookie_auth(void *arg) 46+32+32); crypto_hmac_sha256(hmac2, (char*)ext_or_auth_cookie, 32, client_hash_input, 46+32+32); - tt_mem_op(hmac1,==, reply2, 32); - tt_mem_op(hmac2,==, client_hash2, 32); + tt_mem_op(hmac1,OP_EQ, reply2, 32); + tt_mem_op(hmac2,OP_EQ, client_hash2, 32);

done: tor_free(reply); @@ -334,12 +334,12 @@ test_ext_or_cookie_auth_testvec(void *arg)

MOCK(crypto_rand, crypto_rand_return_tse_str);

- tt_int_op(0, ==, + tt_int_op(0, OP_EQ, handle_client_auth_nonce(client_nonce, 32, &client_hash, &reply, &reply_len)); - tt_ptr_op(reply, !=, NULL ); - tt_uint_op(reply_len, ==, 64); - tt_mem_op(reply+32,==, "te road There is always another ", 32); + tt_ptr_op(reply, OP_NE, NULL ); + tt_uint_op(reply_len, OP_EQ, 64); + tt_mem_op(reply+32,OP_EQ, "te road There is always another ", 32); /* HMACSHA256("Gliding wrapt in a brown mantle," * "ExtORPort authentication server-to-client hash" * "But when I look ahead up the write road There is always another "); @@ -402,11 +402,11 @@ handshake_start(or_connection_t *conn, int receiving) } while (0) #define CONTAINS(s,n) \ do { \ - tt_int_op((n), <=, sizeof(b)); \ - tt_int_op(buf_datalen(TO_CONN(conn)->outbuf), ==, (n)); \ + tt_int_op((n), OP_LE, sizeof(b)); \ + tt_int_op(buf_datalen(TO_CONN(conn)->outbuf), OP_EQ, (n)); \ if ((n)) { \ fetch_from_buf(b, (n), TO_CONN(conn)->outbuf); \ - tt_mem_op(b, ==, (s), (n)); \ + tt_mem_op(b, OP_EQ, (s), (n)); \ } \ } while (0)

@@ -416,14 +416,14 @@ do_ext_or_handshake(or_connection_t *conn) { char b[256];

- tt_int_op(0, ==, connection_ext_or_start_auth(conn)); + tt_int_op(0, OP_EQ, connection_ext_or_start_auth(conn)); CONTAINS("\x01\x00", 2); WRITE("\x01", 1); WRITE("But when I look ahead up the whi", 32); MOCK(crypto_rand, crypto_rand_return_tse_str); - tt_int_op(0, ==, connection_ext_or_process_inbuf(conn)); + tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn)); UNMOCK(crypto_rand); - tt_int_op(TO_CONN(conn)->state, ==, EXT_OR_CONN_STATE_AUTH_WAIT_CLIENT_HASH); + tt_int_op(TO_CONN(conn)->state, OP_EQ, EXT_OR_CONN_STATE_AUTH_WAIT_CLIENT_HASH); CONTAINS("\xec\x80\xed\x6e\x54\x6d\x3b\x36\xfd\xfc\x22\xfe\x13\x15\x41\x6b" "\x02\x9f\x1a\xde\x76\x10\xd9\x10\x87\x8b\x62\xee\xb7\x40\x38\x21" "te road There is always another ", 64); @@ -431,10 +431,10 @@ do_ext_or_handshake(or_connection_t *conn) WRITE("\xab\x39\x17\x32\xdd\x2e\xd9\x68\xcd\x40\xc0\x87\xd1\xb1\xf2\x5b" "\x33\xb3\xcd\x77\xff\x79\xbd\x80\xc2\x07\x4b\xbf\x43\x81\x19\xa2", 32); - tt_int_op(0, ==, connection_ext_or_process_inbuf(conn)); + tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn)); CONTAINS("\x01", 1); tt_assert(! TO_CONN(conn)->marked_for_close); - tt_int_op(TO_CONN(conn)->state, ==, EXT_OR_CONN_STATE_OPEN); + tt_int_op(TO_CONN(conn)->state, OP_EQ, EXT_OR_CONN_STATE_OPEN);

done: ; } @@ -456,14 +456,14 @@ test_ext_or_handshake(void *arg) init_connection_lists();

conn = or_connection_new(CONN_TYPE_EXT_OR, AF_INET); - tt_int_op(0, ==, connection_ext_or_start_auth(conn)); + tt_int_op(0, OP_EQ, connection_ext_or_start_auth(conn)); /* The server starts by telling us about the one supported authtype. */ CONTAINS("\x01\x00", 2); /* Say the client hasn't responded yet. */ - tt_int_op(0, ==, connection_ext_or_process_inbuf(conn)); + tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn)); /* Let's say the client replies badly. */ WRITE("\x99", 1); - tt_int_op(-1, ==, connection_ext_or_process_inbuf(conn)); + tt_int_op(-1, OP_EQ, connection_ext_or_process_inbuf(conn)); CONTAINS("", 0); tt_assert(TO_CONN(conn)->marked_for_close); close_closeable_connections(); @@ -471,23 +471,23 @@ test_ext_or_handshake(void *arg)

/* Okay, try again. */ conn = or_connection_new(CONN_TYPE_EXT_OR, AF_INET); - tt_int_op(0, ==, connection_ext_or_start_auth(conn)); + tt_int_op(0, OP_EQ, connection_ext_or_start_auth(conn)); CONTAINS("\x01\x00", 2); /* Let's say the client replies sensibly this time. "Yes, AUTHTYPE_COOKIE * sounds delicious. Let's have some of that!" */ WRITE("\x01", 1); /* Let's say that the client also sends part of a nonce. */ WRITE("But when I look ", 16); - tt_int_op(0, ==, connection_ext_or_process_inbuf(conn)); + tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn)); CONTAINS("", 0); - tt_int_op(TO_CONN(conn)->state, ==, + tt_int_op(TO_CONN(conn)->state, OP_EQ, EXT_OR_CONN_STATE_AUTH_WAIT_CLIENT_NONCE); /* Pump it again. Nothing should happen. */ - tt_int_op(0, ==, connection_ext_or_process_inbuf(conn)); + tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn)); /* send the rest of the nonce. */ WRITE("ahead up the whi", 16); MOCK(crypto_rand, crypto_rand_return_tse_str); - tt_int_op(0, ==, connection_ext_or_process_inbuf(conn)); + tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn)); UNMOCK(crypto_rand); /* We should get the right reply from the server. */ CONTAINS("\xec\x80\xed\x6e\x54\x6d\x3b\x36\xfd\xfc\x22\xfe\x13\x15\x41\x6b" @@ -496,7 +496,7 @@ test_ext_or_handshake(void *arg) /* Send the wrong response. */ WRITE("not with a bang but a whimper...", 32); MOCK(control_event_bootstrap_problem, ignore_bootstrap_problem); - tt_int_op(-1, ==, connection_ext_or_process_inbuf(conn)); + tt_int_op(-1, OP_EQ, connection_ext_or_process_inbuf(conn)); CONTAINS("\x00", 1); tt_assert(TO_CONN(conn)->marked_for_close); /* XXXX Hold-open-until-flushed. */ @@ -515,32 +515,32 @@ test_ext_or_handshake(void *arg) /* Now let's run through some messages. */ /* First let's send some junk and make sure it's ignored. */ WRITE("\xff\xf0\x00\x03""ABC", 7); - tt_int_op(0, ==, connection_ext_or_process_inbuf(conn)); + tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn)); CONTAINS("", 0); /* Now let's send a USERADDR command. */ WRITE("\x00\x01\x00\x0c""1.2.3.4:5678", 16); - tt_int_op(0, ==, connection_ext_or_process_inbuf(conn)); - tt_int_op(TO_CONN(conn)->port, ==, 5678); - tt_int_op(tor_addr_to_ipv4h(&TO_CONN(conn)->addr), ==, 0x01020304); + tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn)); + tt_int_op(TO_CONN(conn)->port, OP_EQ, 5678); + tt_int_op(tor_addr_to_ipv4h(&TO_CONN(conn)->addr), OP_EQ, 0x01020304); /* Now let's send a TRANSPORT command. */ WRITE("\x00\x02\x00\x07""rfc1149", 11); - tt_int_op(0, ==, connection_ext_or_process_inbuf(conn)); - tt_ptr_op(NULL, !=, conn->ext_or_transport); - tt_str_op("rfc1149", ==, conn->ext_or_transport); - tt_int_op(is_reading,==,1); - tt_int_op(TO_CONN(conn)->state, ==, EXT_OR_CONN_STATE_OPEN); + tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn)); + tt_ptr_op(NULL, OP_NE, conn->ext_or_transport); + tt_str_op("rfc1149", OP_EQ, conn->ext_or_transport); + tt_int_op(is_reading,OP_EQ,1); + tt_int_op(TO_CONN(conn)->state, OP_EQ, EXT_OR_CONN_STATE_OPEN); /* DONE */ WRITE("\x00\x00\x00\x00", 4); - tt_int_op(0, ==, connection_ext_or_process_inbuf(conn)); - tt_int_op(TO_CONN(conn)->state, ==, EXT_OR_CONN_STATE_FLUSHING); - tt_int_op(is_reading,==,0); + tt_int_op(0, OP_EQ, connection_ext_or_process_inbuf(conn)); + tt_int_op(TO_CONN(conn)->state, OP_EQ, EXT_OR_CONN_STATE_FLUSHING); + tt_int_op(is_reading,OP_EQ,0); CONTAINS("\x10\x00\x00\x00", 4); - tt_int_op(handshake_start_called,==,0); - tt_int_op(0, ==, connection_ext_or_finished_flushing(conn)); - tt_int_op(is_reading,==,1); - tt_int_op(handshake_start_called,==,1); - tt_int_op(TO_CONN(conn)->type, ==, CONN_TYPE_OR); - tt_int_op(TO_CONN(conn)->state, ==, 0); + tt_int_op(handshake_start_called,OP_EQ,0); + tt_int_op(0, OP_EQ, connection_ext_or_finished_flushing(conn)); + tt_int_op(is_reading,OP_EQ,1); + tt_int_op(handshake_start_called,OP_EQ,1); + tt_int_op(TO_CONN(conn)->type, OP_EQ, CONN_TYPE_OR); + tt_int_op(TO_CONN(conn)->state, OP_EQ, 0); close_closeable_connections(); conn = NULL;

@@ -551,7 +551,7 @@ test_ext_or_handshake(void *arg) /* USERADDR command with an extra NUL byte */ WRITE("\x00\x01\x00\x0d""1.2.3.4:5678\x00", 17); MOCK(control_event_bootstrap_problem, ignore_bootstrap_problem); - tt_int_op(-1, ==, connection_ext_or_process_inbuf(conn)); + tt_int_op(-1, OP_EQ, connection_ext_or_process_inbuf(conn)); CONTAINS("", 0); tt_assert(TO_CONN(conn)->marked_for_close); close_closeable_connections(); @@ -564,7 +564,7 @@ test_ext_or_handshake(void *arg) /* TRANSPORT command with an extra NUL byte */ WRITE("\x00\x02\x00\x08""rfc1149\x00", 12); MOCK(control_event_bootstrap_problem, ignore_bootstrap_problem); - tt_int_op(-1, ==, connection_ext_or_process_inbuf(conn)); + tt_int_op(-1, OP_EQ, connection_ext_or_process_inbuf(conn)); CONTAINS("", 0); tt_assert(TO_CONN(conn)->marked_for_close); close_closeable_connections(); @@ -578,7 +578,7 @@ test_ext_or_handshake(void *arg) C-identifier) */ WRITE("\x00\x02\x00\x07""rf*1149", 11); MOCK(control_event_bootstrap_problem, ignore_bootstrap_problem); - tt_int_op(-1, ==, connection_ext_or_process_inbuf(conn)); + tt_int_op(-1, OP_EQ, connection_ext_or_process_inbuf(conn)); CONTAINS("", 0); tt_assert(TO_CONN(conn)->marked_for_close); close_closeable_connections(); diff --git a/src/test/test_hs.c b/src/test/test_hs.c index c482001..2db88a4 100644 --- a/src/test/test_hs.c +++ b/src/test/test_hs.c @@ -85,7 +85,7 @@ test_hs_desc_event(void *arg) expected_msg = "650 HS_DESC REQUESTED "STR_HS_ADDR" NO_AUTH "\ STR_HSDIR_EXIST_LONGNAME" "STR_HS_ID"\r\n"; tt_assert(received_msg); - tt_str_op(received_msg,==, expected_msg); + tt_str_op(received_msg,OP_EQ, expected_msg); tor_free(received_msg);

/* test received event */ @@ -94,7 +94,7 @@ test_hs_desc_event(void *arg) expected_msg = "650 HS_DESC RECEIVED "STR_HS_ADDR" BASIC_AUTH "\ STR_HSDIR_EXIST_LONGNAME"\r\n"; tt_assert(received_msg); - tt_str_op(received_msg,==, expected_msg); + tt_str_op(received_msg,OP_EQ, expected_msg); tor_free(received_msg);

/* test failed event */ @@ -103,7 +103,7 @@ test_hs_desc_event(void *arg) expected_msg = "650 HS_DESC FAILED "STR_HS_ADDR" STEALTH_AUTH "\ STR_HSDIR_NONE_EXIST_LONGNAME"\r\n"; tt_assert(received_msg); - tt_str_op(received_msg,==, expected_msg); + tt_str_op(received_msg,OP_EQ, expected_msg); tor_free(received_msg);

/* test invalid auth type */ @@ -112,7 +112,7 @@ test_hs_desc_event(void *arg) expected_msg = "650 HS_DESC FAILED "STR_HS_ADDR" UNKNOWN "\ STR_HSDIR_EXIST_LONGNAME"\r\n"; tt_assert(received_msg); - tt_str_op(received_msg,==, expected_msg); + tt_str_op(received_msg,OP_EQ, expected_msg); tor_free(received_msg);

done: diff --git a/src/test/test_introduce.c b/src/test/test_introduce.c index 0febd59..fe8ffbf 100644 --- a/src/test/test_introduce.c +++ b/src/test/test_introduce.c @@ -310,7 +310,7 @@ do_parse_test(uint8_t *plaintext, size_t plaintext_len, int phase) parsed_req = rend_service_begin_parse_intro(cell, cell_len, 2, &err_msg); tt_assert(parsed_req); tt_assert(!err_msg); - tt_mem_op(parsed_req->pk,==, digest, DIGEST_LEN); + tt_mem_op(parsed_req->pk,OP_EQ, digest, DIGEST_LEN); tt_assert(parsed_req->ciphertext); tt_assert(parsed_req->ciphertext_len > 0);

diff --git a/src/test/test_logging.c b/src/test/test_logging.c index 9d9cbae..17f1ed5 100644 --- a/src/test/test_logging.c +++ b/src/test/test_logging.c @@ -22,8 +22,8 @@ test_get_sigsafe_err_fds(void *arg) init_logging(1);

n = tor_log_get_sigsafe_err_fds(&fds); - tt_int_op(n, ==, 1); - tt_int_op(fds[0], ==, STDERR_FILENO); + tt_int_op(n, OP_EQ, 1); + tt_int_op(fds[0], OP_EQ, STDERR_FILENO);

set_log_severity_config(LOG_WARN, LOG_ERR, &include_bug); set_log_severity_config(LOG_WARN, LOG_ERR, &no_bug); @@ -40,26 +40,26 @@ test_get_sigsafe_err_fds(void *arg) tor_log_update_sigsafe_err_fds();

n = tor_log_get_sigsafe_err_fds(&fds); - tt_int_op(n, ==, 2); - tt_int_op(fds[0], ==, STDERR_FILENO); - tt_int_op(fds[1], ==, 3); + tt_int_op(n, OP_EQ, 2); + tt_int_op(fds[0], OP_EQ, STDERR_FILENO); + tt_int_op(fds[1], OP_EQ, 3);

/* Allow STDOUT to replace STDERR. */ add_stream_log(&include_bug, "dummy-4", STDOUT_FILENO); tor_log_update_sigsafe_err_fds(); n = tor_log_get_sigsafe_err_fds(&fds); - tt_int_op(n, ==, 2); - tt_int_op(fds[0], ==, 3); - tt_int_op(fds[1], ==, STDOUT_FILENO); + tt_int_op(n, OP_EQ, 2); + tt_int_op(fds[0], OP_EQ, 3); + tt_int_op(fds[1], OP_EQ, STDOUT_FILENO);

/* But don't allow it to replace explicit STDERR. */ add_stream_log(&include_bug, "dummy-5", STDERR_FILENO); tor_log_update_sigsafe_err_fds(); n = tor_log_get_sigsafe_err_fds(&fds); - tt_int_op(n, ==, 3); - tt_int_op(fds[0], ==, STDERR_FILENO); - tt_int_op(fds[1], ==, STDOUT_FILENO); - tt_int_op(fds[2], ==, 3); + tt_int_op(n, OP_EQ, 3); + tt_int_op(fds[0], OP_EQ, STDERR_FILENO); + tt_int_op(fds[1], OP_EQ, STDOUT_FILENO); + tt_int_op(fds[2], OP_EQ, 3);

/* Don't overflow the array. */ { @@ -70,7 +70,7 @@ test_get_sigsafe_err_fds(void *arg) } tor_log_update_sigsafe_err_fds(); n = tor_log_get_sigsafe_err_fds(&fds); - tt_int_op(n, ==, 8); + tt_int_op(n, OP_EQ, 8);

done: ; @@ -109,7 +109,7 @@ test_sigsafe_err(void *arg)

tt_assert(content != NULL); tor_split_lines(lines, content, (int)strlen(content)); - tt_int_op(smartlist_len(lines), >=, 5); + tt_int_op(smartlist_len(lines), OP_GE, 5);

if (strstr(smartlist_get(lines, 0), "opening new log file")) smartlist_del_keeporder(lines, 0); @@ -119,7 +119,7 @@ test_sigsafe_err(void *arg) tt_assert(!strcmpstart(smartlist_get(lines, 2), "Minimal.")); /* Next line is blank. */ tt_assert(!strcmpstart(smartlist_get(lines, 3), "==============")); - tt_str_op(smartlist_get(lines, 4), ==, + tt_str_op(smartlist_get(lines, 4), OP_EQ, "Testing any attempt to manually log from a signal.");

done: diff --git a/src/test/test_microdesc.c b/src/test/test_microdesc.c index aa4bdf2..4a7c29b 100644 --- a/src/test/test_microdesc.c +++ b/src/test/test_microdesc.c @@ -75,9 +75,9 @@ test_md_cache(void *data) tor_free(options->DataDirectory); options->DataDirectory = tor_strdup(get_fname("md_datadir_test")); #ifdef _WIN32 - tt_int_op(0, ==, mkdir(options->DataDirectory)); + tt_int_op(0, OP_EQ, mkdir(options->DataDirectory)); #else - tt_int_op(0, ==, mkdir(options->DataDirectory, 0700)); + tt_int_op(0, OP_EQ, mkdir(options->DataDirectory, 0700)); #endif

tt_assert(!strcmpstart(test_md3_noannotation, "onion-key")); @@ -91,7 +91,7 @@ test_md_cache(void *data)

added = microdescs_add_to_cache(mc, test_md1, NULL, SAVED_NOWHERE, 0, time1, NULL); - tt_int_op(1, ==, smartlist_len(added)); + tt_int_op(1, OP_EQ, smartlist_len(added)); md1 = smartlist_get(added, 0); smartlist_free(added); added = NULL; @@ -100,7 +100,7 @@ test_md_cache(void *data) added = microdescs_add_to_cache(mc, test_md2, NULL, SAVED_NOWHERE, 0, time2, wanted); /* Should fail, since we didn't list test_md2's digest in wanted */ - tt_int_op(0, ==, smartlist_len(added)); + tt_int_op(0, OP_EQ, smartlist_len(added)); smartlist_free(added); added = NULL;

@@ -109,75 +109,75 @@ test_md_cache(void *data) added = microdescs_add_to_cache(mc, test_md2, NULL, SAVED_NOWHERE, 0, time2, wanted); /* Now it can work. md2 should have been added */ - tt_int_op(1, ==, smartlist_len(added)); + tt_int_op(1, OP_EQ, smartlist_len(added)); md2 = smartlist_get(added, 0); /* And it should have gotten removed from 'wanted' */ - tt_int_op(smartlist_len(wanted), ==, 1); - tt_mem_op(smartlist_get(wanted, 0), ==, d3, DIGEST256_LEN); + tt_int_op(smartlist_len(wanted), OP_EQ, 1); + tt_mem_op(smartlist_get(wanted, 0), OP_EQ, d3, DIGEST256_LEN); smartlist_free(added); added = NULL;

added = microdescs_add_to_cache(mc, test_md3, NULL, SAVED_NOWHERE, 0, -1, NULL); /* Must fail, since SAVED_NOWHERE precludes annotations */ - tt_int_op(0, ==, smartlist_len(added)); + tt_int_op(0, OP_EQ, smartlist_len(added)); smartlist_free(added); added = NULL;

added = microdescs_add_to_cache(mc, test_md3_noannotation, NULL, SAVED_NOWHERE, 0, time3, NULL); /* Now it can work */ - tt_int_op(1, ==, smartlist_len(added)); + tt_int_op(1, OP_EQ, smartlist_len(added)); md3 = smartlist_get(added, 0); smartlist_free(added); added = NULL;

/* Okay. We added 1...3. Let's poke them to see how they look, and make * sure they're really in the journal. */ - tt_ptr_op(md1, ==, microdesc_cache_lookup_by_digest256(mc, d1)); - tt_ptr_op(md2, ==, microdesc_cache_lookup_by_digest256(mc, d2)); - tt_ptr_op(md3, ==, microdesc_cache_lookup_by_digest256(mc, d3)); - - tt_int_op(md1->last_listed, ==, time1); - tt_int_op(md2->last_listed, ==, time2); - tt_int_op(md3->last_listed, ==, time3); - - tt_int_op(md1->saved_location, ==, SAVED_IN_JOURNAL); - tt_int_op(md2->saved_location, ==, SAVED_IN_JOURNAL); - tt_int_op(md3->saved_location, ==, SAVED_IN_JOURNAL); - - tt_int_op(md1->bodylen, ==, strlen(test_md1)); - tt_int_op(md2->bodylen, ==, strlen(test_md2)); - tt_int_op(md3->bodylen, ==, strlen(test_md3_noannotation)); - tt_mem_op(md1->body, ==, test_md1, strlen(test_md1)); - tt_mem_op(md2->body, ==, test_md2, strlen(test_md2)); - tt_mem_op(md3->body, ==, test_md3_noannotation, + tt_ptr_op(md1, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d1)); + tt_ptr_op(md2, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d2)); + tt_ptr_op(md3, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d3)); + + tt_int_op(md1->last_listed, OP_EQ, time1); + tt_int_op(md2->last_listed, OP_EQ, time2); + tt_int_op(md3->last_listed, OP_EQ, time3); + + tt_int_op(md1->saved_location, OP_EQ, SAVED_IN_JOURNAL); + tt_int_op(md2->saved_location, OP_EQ, SAVED_IN_JOURNAL); + tt_int_op(md3->saved_location, OP_EQ, SAVED_IN_JOURNAL); + + tt_int_op(md1->bodylen, OP_EQ, strlen(test_md1)); + tt_int_op(md2->bodylen, OP_EQ, strlen(test_md2)); + tt_int_op(md3->bodylen, OP_EQ, strlen(test_md3_noannotation)); + tt_mem_op(md1->body, OP_EQ, test_md1, strlen(test_md1)); + tt_mem_op(md2->body, OP_EQ, test_md2, strlen(test_md2)); + tt_mem_op(md3->body, OP_EQ, test_md3_noannotation, strlen(test_md3_noannotation));

tor_asprintf(&fn, "%s"PATH_SEPARATOR"cached-microdescs.new", options->DataDirectory); s = read_file_to_str(fn, RFTS_BIN, NULL); tt_assert(s); - tt_mem_op(md1->body, ==, s + md1->off, md1->bodylen); - tt_mem_op(md2->body, ==, s + md2->off, md2->bodylen); - tt_mem_op(md3->body, ==, s + md3->off, md3->bodylen); + tt_mem_op(md1->body, OP_EQ, s + md1->off, md1->bodylen); + tt_mem_op(md2->body, OP_EQ, s + md2->off, md2->bodylen); + tt_mem_op(md3->body, OP_EQ, s + md3->off, md3->bodylen);

- tt_ptr_op(md1->family, ==, NULL); - tt_ptr_op(md3->family, !=, NULL); - tt_int_op(smartlist_len(md3->family), ==, 3); - tt_str_op(smartlist_get(md3->family, 0), ==, "nodeX"); + tt_ptr_op(md1->family, OP_EQ, NULL); + tt_ptr_op(md3->family, OP_NE, NULL); + tt_int_op(smartlist_len(md3->family), OP_EQ, 3); + tt_str_op(smartlist_get(md3->family, 0), OP_EQ, "nodeX");

/* Now rebuild the cache! */ - tt_int_op(microdesc_cache_rebuild(mc, 1), ==, 0); + tt_int_op(microdesc_cache_rebuild(mc, 1), OP_EQ, 0);

- tt_int_op(md1->saved_location, ==, SAVED_IN_CACHE); - tt_int_op(md2->saved_location, ==, SAVED_IN_CACHE); - tt_int_op(md3->saved_location, ==, SAVED_IN_CACHE); + tt_int_op(md1->saved_location, OP_EQ, SAVED_IN_CACHE); + tt_int_op(md2->saved_location, OP_EQ, SAVED_IN_CACHE); + tt_int_op(md3->saved_location, OP_EQ, SAVED_IN_CACHE);

/* The journal should be empty now */ tor_free(s); s = read_file_to_str(fn, RFTS_BIN, NULL); - tt_str_op(s, ==, ""); + tt_str_op(s, OP_EQ, ""); tor_free(s); tor_free(fn);

@@ -185,9 +185,9 @@ test_md_cache(void *data) tor_asprintf(&fn, "%s"PATH_SEPARATOR"cached-microdescs", options->DataDirectory); s = read_file_to_str(fn, RFTS_BIN, NULL); - tt_mem_op(md1->body, ==, s + md1->off, strlen(test_md1)); - tt_mem_op(md2->body, ==, s + md2->off, strlen(test_md2)); - tt_mem_op(md3->body, ==, s + md3->off, strlen(test_md3_noannotation)); + tt_mem_op(md1->body, OP_EQ, s + md1->off, strlen(test_md1)); + tt_mem_op(md2->body, OP_EQ, s + md2->off, strlen(test_md2)); + tt_mem_op(md3->body, OP_EQ, s + md3->off, strlen(test_md3_noannotation));

/* Okay, now we are going to forget about the cache entirely, and reload it * from the disk. */ @@ -199,41 +199,41 @@ test_md_cache(void *data) tt_assert(md1); tt_assert(md2); tt_assert(md3); - tt_mem_op(md1->body, ==, s + md1->off, strlen(test_md1)); - tt_mem_op(md2->body, ==, s + md2->off, strlen(test_md2)); - tt_mem_op(md3->body, ==, s + md3->off, strlen(test_md3_noannotation)); + tt_mem_op(md1->body, OP_EQ, s + md1->off, strlen(test_md1)); + tt_mem_op(md2->body, OP_EQ, s + md2->off, strlen(test_md2)); + tt_mem_op(md3->body, OP_EQ, s + md3->off, strlen(test_md3_noannotation));

- tt_int_op(md1->last_listed, ==, time1); - tt_int_op(md2->last_listed, ==, time2); - tt_int_op(md3->last_listed, ==, time3); + tt_int_op(md1->last_listed, OP_EQ, time1); + tt_int_op(md2->last_listed, OP_EQ, time2); + tt_int_op(md3->last_listed, OP_EQ, time3);

/* Okay, now we are going to clear out everything older than a week old. * In practice, that means md3 */ microdesc_cache_clean(mc, time(NULL)-7*24*60*60, 1/*force*/); - tt_ptr_op(md1, ==, microdesc_cache_lookup_by_digest256(mc, d1)); - tt_ptr_op(md2, ==, microdesc_cache_lookup_by_digest256(mc, d2)); - tt_ptr_op(NULL, ==, microdesc_cache_lookup_by_digest256(mc, d3)); + tt_ptr_op(md1, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d1)); + tt_ptr_op(md2, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d2)); + tt_ptr_op(NULL, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d3)); md3 = NULL; /* it's history now! */

/* rebuild again, make sure it stays gone. */ - tt_int_op(microdesc_cache_rebuild(mc, 1), ==, 0); - tt_ptr_op(md1, ==, microdesc_cache_lookup_by_digest256(mc, d1)); - tt_ptr_op(md2, ==, microdesc_cache_lookup_by_digest256(mc, d2)); - tt_ptr_op(NULL, ==, microdesc_cache_lookup_by_digest256(mc, d3)); + tt_int_op(microdesc_cache_rebuild(mc, 1), OP_EQ, 0); + tt_ptr_op(md1, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d1)); + tt_ptr_op(md2, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d2)); + tt_ptr_op(NULL, OP_EQ, microdesc_cache_lookup_by_digest256(mc, d3));

/* Re-add md3, and make sure we can rebuild the cache. */ added = microdescs_add_to_cache(mc, test_md3_noannotation, NULL, SAVED_NOWHERE, 0, time3, NULL); - tt_int_op(1, ==, smartlist_len(added)); + tt_int_op(1, OP_EQ, smartlist_len(added)); md3 = smartlist_get(added, 0); smartlist_free(added); added = NULL; - tt_int_op(md1->saved_location, ==, SAVED_IN_CACHE); - tt_int_op(md2->saved_location, ==, SAVED_IN_CACHE); - tt_int_op(md3->saved_location, ==, SAVED_IN_JOURNAL); + tt_int_op(md1->saved_location, OP_EQ, SAVED_IN_CACHE); + tt_int_op(md2->saved_location, OP_EQ, SAVED_IN_CACHE); + tt_int_op(md3->saved_location, OP_EQ, SAVED_IN_JOURNAL);

- tt_int_op(microdesc_cache_rebuild(mc, 1), ==, 0); - tt_int_op(md3->saved_location, ==, SAVED_IN_CACHE); + tt_int_op(microdesc_cache_rebuild(mc, 1), OP_EQ, 0); + tt_int_op(md3->saved_location, OP_EQ, SAVED_IN_CACHE);

done: if (options) @@ -273,9 +273,9 @@ test_md_cache_broken(void *data) options->DataDirectory = tor_strdup(get_fname("md_datadir_test2"));

#ifdef _WIN32 - tt_int_op(0, ==, mkdir(options->DataDirectory)); + tt_int_op(0, OP_EQ, mkdir(options->DataDirectory)); #else - tt_int_op(0, ==, mkdir(options->DataDirectory, 0700)); + tt_int_op(0, OP_EQ, mkdir(options->DataDirectory, 0700)); #endif

tor_asprintf(&fn, "%s"PATH_SEPARATOR"cached-microdescs", @@ -375,7 +375,7 @@ test_md_generate(void *arg) ri = router_parse_entry_from_string(test_ri, NULL, 0, 0, NULL, NULL); tt_assert(ri); md = dirvote_create_microdescriptor(ri, 8); - tt_str_op(md->body, ==, test_md_8); + tt_str_op(md->body, OP_EQ, test_md_8);

/* XXXX test family lines. */ /* XXXX test method 14 for A lines. */ @@ -384,12 +384,12 @@ test_md_generate(void *arg) microdesc_free(md); md = NULL; md = dirvote_create_microdescriptor(ri, 16); - tt_str_op(md->body, ==, test_md_16); + tt_str_op(md->body, OP_EQ, test_md_16);

microdesc_free(md); md = NULL; md = dirvote_create_microdescriptor(ri, 18); - tt_str_op(md->body, ==, test_md_18); + tt_str_op(md->body, OP_EQ, test_md_18);

done: microdesc_free(md); @@ -564,8 +564,8 @@ test_md_parse(void *arg) smartlist_t *mds = microdescs_parse_from_string(MD_PARSE_TEST_DATA, NULL, 1, SAVED_NOWHERE, invalid); - tt_int_op(smartlist_len(mds), ==, 11); - tt_int_op(smartlist_len(invalid), ==, 4); + tt_int_op(smartlist_len(mds), OP_EQ, 11); + tt_int_op(smartlist_len(invalid), OP_EQ, 4);

test_memeq_hex(smartlist_get(invalid,0), "5d76bf1c6614e885614a1e0ad074e1ab" @@ -585,11 +585,11 @@ test_md_parse(void *arg) test_memeq_hex(md->digest, "54bb6d733ddeb375d2456c79ae103961" "da0cae29620375ac4cf13d54da4d92b3"); - tt_int_op(md->last_listed, ==, 0); - tt_int_op(md->saved_location, ==, SAVED_NOWHERE); - tt_int_op(md->no_save, ==, 0); - tt_uint_op(md->held_in_map, ==, 0); - tt_uint_op(md->held_by_nodes, ==, 0); + tt_int_op(md->last_listed, OP_EQ, 0); + tt_int_op(md->saved_location, OP_EQ, SAVED_NOWHERE); + tt_int_op(md->no_save, OP_EQ, 0); + tt_uint_op(md->held_in_map, OP_EQ, 0); + tt_uint_op(md->held_by_nodes, OP_EQ, 0); tt_assert(md->onion_curve25519_pkey);

md = smartlist_get(mds, 6); @@ -609,7 +609,7 @@ test_md_parse(void *arg) "409ebd87d23925a2732bd467a92813c9" "21ca378fcb9ca193d354c51550b6d5e9"); tt_assert(tor_addr_family(&md->ipv6_addr) == AF_INET6); - tt_int_op(md->ipv6_orport, ==, 9090); + tt_int_op(md->ipv6_orport, OP_EQ, 9090);

done: SMARTLIST_FOREACH(mds, microdesc_t *, md, microdesc_free(md)); @@ -667,9 +667,9 @@ test_md_reject_cache(void *arg) mock_ns_val->flavor = FLAV_MICRODESC;

#ifdef _WIN32 - tt_int_op(0, ==, mkdir(options->DataDirectory)); + tt_int_op(0, OP_EQ, mkdir(options->DataDirectory)); #else - tt_int_op(0, ==, mkdir(options->DataDirectory, 0700)); + tt_int_op(0, OP_EQ, mkdir(options->DataDirectory, 0700)); #endif

MOCK(router_get_mutable_consensus_status_by_descriptor_digest, @@ -679,7 +679,7 @@ test_md_reject_cache(void *arg) mc = get_microdesc_cache(); #define ADD(hex) \ do { \ - tt_int_op(0,==,base16_decode(buf,sizeof(buf),hex,strlen(hex))); \ + tt_int_op(0,OP_EQ,base16_decode(buf,sizeof(buf),hex,strlen(hex))); \ smartlist_add(wanted, tor_memdup(buf, DIGEST256_LEN)); \ } while (0)

@@ -695,10 +695,10 @@ test_md_reject_cache(void *arg) added = microdescs_add_to_cache(mc, MD_PARSE_TEST_DATA, NULL, SAVED_NOWHERE, 0, time(NULL), wanted);

- tt_int_op(smartlist_len(added), ==, 2); - tt_int_op(mock_rgsbd_called, ==, 2); - tt_int_op(mock_rgsbd_val_a->dl_status.n_download_failures, ==, 255); - tt_int_op(mock_rgsbd_val_b->dl_status.n_download_failures, ==, 255); + tt_int_op(smartlist_len(added), OP_EQ, 2); + tt_int_op(mock_rgsbd_called, OP_EQ, 2); + tt_int_op(mock_rgsbd_val_a->dl_status.n_download_failures, OP_EQ, 255); + tt_int_op(mock_rgsbd_val_b->dl_status.n_download_failures, OP_EQ, 255);

done: UNMOCK(networkstatus_get_latest_consensus_by_flavor); diff --git a/src/test/test_nodelist.c b/src/test/test_nodelist.c index 7c94084..2fba3da 100644 --- a/src/test/test_nodelist.c +++ b/src/test/test_nodelist.c @@ -25,7 +25,7 @@ test_nodelist_node_get_verbose_nickname_by_id_null_node(void *arg) /* make sure node_get_by_id returns NULL */ tt_assert(!node_get_by_id(ID)); node_get_verbose_nickname_by_id(ID, vname); - tt_str_op(vname,==, "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"); + tt_str_op(vname,OP_EQ, "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"); done: return; } @@ -54,7 +54,7 @@ test_nodelist_node_get_verbose_nickname_not_named(void *arg) "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA", DIGEST_LEN); node_get_verbose_nickname(&mock_node, vname); - tt_str_op(vname,==, "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA~TestOR"); + tt_str_op(vname,OP_EQ, "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA~TestOR");

done: return; diff --git a/src/test/test_oom.c b/src/test/test_oom.c index 2726056..1f21f65 100644 --- a/src/test/test_oom.c +++ b/src/test/test_oom.c @@ -151,9 +151,9 @@ test_oom_circbuf(void *arg) options->MaxMemInQueues = 256*packed_cell_mem_cost(); options->CellStatistics = 0;

- tt_int_op(cell_queues_check_size(), ==, 0); /* We don't start out OOM. */ - tt_int_op(cell_queues_get_total_allocation(), ==, 0); - tt_int_op(buf_get_total_allocation(), ==, 0); + tt_int_op(cell_queues_check_size(), OP_EQ, 0); /* We don't start out OOM. */ + tt_int_op(cell_queues_get_total_allocation(), OP_EQ, 0); + tt_int_op(buf_get_total_allocation(), OP_EQ, 0);

/* Now we're going to fake up some circuits and get them added to the global circuit list. */ @@ -165,21 +165,21 @@ test_oom_circbuf(void *arg) c2 = dummy_or_circuit_new(20, 20);

#ifdef ENABLE_MEMPOOLS - tt_int_op(packed_cell_mem_cost(), ==, + tt_int_op(packed_cell_mem_cost(), OP_EQ, sizeof(packed_cell_t) + MP_POOL_ITEM_OVERHEAD); #else - tt_int_op(packed_cell_mem_cost(), ==, + tt_int_op(packed_cell_mem_cost(), OP_EQ, sizeof(packed_cell_t)); #endif /* ENABLE_MEMPOOLS */ - tt_int_op(cell_queues_get_total_allocation(), ==, + tt_int_op(cell_queues_get_total_allocation(), OP_EQ, packed_cell_mem_cost() * 70); - tt_int_op(cell_queues_check_size(), ==, 0); /* We are still not OOM */ + tt_int_op(cell_queues_check_size(), OP_EQ, 0); /* We are still not OOM */

tv.tv_usec = 20*1000; tor_gettimeofday_cache_set(&tv); c3 = dummy_or_circuit_new(100, 85); - tt_int_op(cell_queues_check_size(), ==, 0); /* We are still not OOM */ - tt_int_op(cell_queues_get_total_allocation(), ==, + tt_int_op(cell_queues_check_size(), OP_EQ, 0); /* We are still not OOM */ + tt_int_op(cell_queues_get_total_allocation(), OP_EQ, packed_cell_mem_cost() * 255);

tv.tv_usec = 30*1000; @@ -187,17 +187,17 @@ test_oom_circbuf(void *arg) /* Adding this cell will trigger our OOM handler. */ c4 = dummy_or_circuit_new(2, 0);

- tt_int_op(cell_queues_get_total_allocation(), ==, + tt_int_op(cell_queues_get_total_allocation(), OP_EQ, packed_cell_mem_cost() * 257);

- tt_int_op(cell_queues_check_size(), ==, 1); /* We are now OOM */ + tt_int_op(cell_queues_check_size(), OP_EQ, 1); /* We are now OOM */

tt_assert(c1->marked_for_close); tt_assert(! c2->marked_for_close); tt_assert(! c3->marked_for_close); tt_assert(! c4->marked_for_close);

- tt_int_op(cell_queues_get_total_allocation(), ==, + tt_int_op(cell_queues_get_total_allocation(), OP_EQ, packed_cell_mem_cost() * (257 - 30));

circuit_free(c1); @@ -208,14 +208,14 @@ test_oom_circbuf(void *arg) tv.tv_usec = 40*1000; /* go back to the future */ tor_gettimeofday_cache_set(&tv);

- tt_int_op(cell_queues_check_size(), ==, 1); /* We are now OOM */ + tt_int_op(cell_queues_check_size(), OP_EQ, 1); /* We are now OOM */

tt_assert(c1->marked_for_close); tt_assert(! c2->marked_for_close); tt_assert(! c3->marked_for_close); tt_assert(! c4->marked_for_close);

- tt_int_op(cell_queues_get_total_allocation(), ==, + tt_int_op(cell_queues_get_total_allocation(), OP_EQ, packed_cell_mem_cost() * (257 - 30));

done: @@ -250,9 +250,9 @@ test_oom_streambuf(void *arg) options->MaxMemInQueues = 81*packed_cell_mem_cost() + 4096 * 34; options->CellStatistics = 0;

- tt_int_op(cell_queues_check_size(), ==, 0); /* We don't start out OOM. */ - tt_int_op(cell_queues_get_total_allocation(), ==, 0); - tt_int_op(buf_get_total_allocation(), ==, 0); + tt_int_op(cell_queues_check_size(), OP_EQ, 0); /* We don't start out OOM. */ + tt_int_op(cell_queues_get_total_allocation(), OP_EQ, 0); + tt_int_op(buf_get_total_allocation(), OP_EQ, 0);

/* Start all circuits with a bit of data queued in cells */ tv.tv_usec = 500*1000; /* go halfway into the second. */ @@ -267,7 +267,7 @@ test_oom_streambuf(void *arg) tv.tv_usec = 530*1000; tor_gettimeofday_cache_set(&tv); c4 = dummy_or_circuit_new(0,0); - tt_int_op(cell_queues_get_total_allocation(), ==, + tt_int_op(cell_queues_get_total_allocation(), OP_EQ, packed_cell_mem_cost() * 80);

tv.tv_usec = 600*1000; @@ -303,24 +303,24 @@ test_oom_streambuf(void *arg) tv.tv_usec = 0; tvms = (uint32_t) tv_to_msec(&tv);

- tt_int_op(circuit_max_queued_cell_age(c1, tvms), ==, 500); - tt_int_op(circuit_max_queued_cell_age(c2, tvms), ==, 490); - tt_int_op(circuit_max_queued_cell_age(c3, tvms), ==, 480); - tt_int_op(circuit_max_queued_cell_age(c4, tvms), ==, 0); + tt_int_op(circuit_max_queued_cell_age(c1, tvms), OP_EQ, 500); + tt_int_op(circuit_max_queued_cell_age(c2, tvms), OP_EQ, 490); + tt_int_op(circuit_max_queued_cell_age(c3, tvms), OP_EQ, 480); + tt_int_op(circuit_max_queued_cell_age(c4, tvms), OP_EQ, 0);

- tt_int_op(circuit_max_queued_data_age(c1, tvms), ==, 390); - tt_int_op(circuit_max_queued_data_age(c2, tvms), ==, 380); - tt_int_op(circuit_max_queued_data_age(c3, tvms), ==, 0); - tt_int_op(circuit_max_queued_data_age(c4, tvms), ==, 370); + tt_int_op(circuit_max_queued_data_age(c1, tvms), OP_EQ, 390); + tt_int_op(circuit_max_queued_data_age(c2, tvms), OP_EQ, 380); + tt_int_op(circuit_max_queued_data_age(c3, tvms), OP_EQ, 0); + tt_int_op(circuit_max_queued_data_age(c4, tvms), OP_EQ, 370);

- tt_int_op(circuit_max_queued_item_age(c1, tvms), ==, 500); - tt_int_op(circuit_max_queued_item_age(c2, tvms), ==, 490); - tt_int_op(circuit_max_queued_item_age(c3, tvms), ==, 480); - tt_int_op(circuit_max_queued_item_age(c4, tvms), ==, 370); + tt_int_op(circuit_max_queued_item_age(c1, tvms), OP_EQ, 500); + tt_int_op(circuit_max_queued_item_age(c2, tvms), OP_EQ, 490); + tt_int_op(circuit_max_queued_item_age(c3, tvms), OP_EQ, 480); + tt_int_op(circuit_max_queued_item_age(c4, tvms), OP_EQ, 370);

- tt_int_op(cell_queues_get_total_allocation(), ==, + tt_int_op(cell_queues_get_total_allocation(), OP_EQ, packed_cell_mem_cost() * 80); - tt_int_op(buf_get_total_allocation(), ==, 4096*16*2); + tt_int_op(buf_get_total_allocation(), OP_EQ, 4096*16*2);

/* Now give c4 a very old buffer of modest size */ { @@ -332,21 +332,21 @@ test_oom_streambuf(void *arg) tt_assert(ec); smartlist_add(edgeconns, ec); } - tt_int_op(buf_get_total_allocation(), ==, 4096*17*2); - tt_int_op(circuit_max_queued_item_age(c4, tvms), ==, 1000); + tt_int_op(buf_get_total_allocation(), OP_EQ, 4096*17*2); + tt_int_op(circuit_max_queued_item_age(c4, tvms), OP_EQ, 1000);

- tt_int_op(cell_queues_check_size(), ==, 0); + tt_int_op(cell_queues_check_size(), OP_EQ, 0);

/* And run over the limit. */ tv.tv_usec = 800*1000; tor_gettimeofday_cache_set(&tv); c5 = dummy_or_circuit_new(0,5);

- tt_int_op(cell_queues_get_total_allocation(), ==, + tt_int_op(cell_queues_get_total_allocation(), OP_EQ, packed_cell_mem_cost() * 85); - tt_int_op(buf_get_total_allocation(), ==, 4096*17*2); + tt_int_op(buf_get_total_allocation(), OP_EQ, 4096*17*2);

- tt_int_op(cell_queues_check_size(), ==, 1); /* We are now OOM */ + tt_int_op(cell_queues_check_size(), OP_EQ, 1); /* We are now OOM */

/* C4 should have died. */ tt_assert(! c1->marked_for_close); @@ -355,9 +355,9 @@ test_oom_streambuf(void *arg) tt_assert(c4->marked_for_close); tt_assert(! c5->marked_for_close);

- tt_int_op(cell_queues_get_total_allocation(), ==, + tt_int_op(cell_queues_get_total_allocation(), OP_EQ, packed_cell_mem_cost() * 85); - tt_int_op(buf_get_total_allocation(), ==, 4096*8*2); + tt_int_op(buf_get_total_allocation(), OP_EQ, 4096*8*2);

done: circuit_free(c1); diff --git a/src/test/test_options.c b/src/test/test_options.c index 57ab38c..44349b3 100644 --- a/src/test/test_options.c +++ b/src/test/test_options.c @@ -87,10 +87,10 @@ test_options_validate_impl(const char *configuration, clear_log_messages();

r = config_get_lines(configuration, &cl, 1); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0);

r = config_assign(&options_format, opt, cl, 0, 0, &msg); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0);

r = options_validate(NULL, opt, dflt, 0, &msg); if (expect_errmsg && !msg) { @@ -103,7 +103,7 @@ test_options_validate_impl(const char *configuration, TT_DIE(("Expected no error message from <%s> but got <%s>.", configuration, msg)); } - tt_int_op((r == 0), ==, (msg == NULL)); + tt_int_op((r == 0), OP_EQ, (msg == NULL));

if (expect_log) { int found = 0; diff --git a/src/test/test_policy.c b/src/test/test_policy.c index c043ac6..e77e16c 100644 --- a/src/test/test_policy.c +++ b/src/test/test_policy.c @@ -22,7 +22,7 @@ test_short_policy_parse(const char *input, short_policy = parse_short_policy(input); tt_assert(short_policy); out = write_short_policy(short_policy); - tt_str_op(out, ==, expected); + tt_str_op(out, OP_EQ, expected);

done: tor_free(out); @@ -50,17 +50,17 @@ test_policy_summary_helper(const char *policy_str, r = policies_parse_exit_policy(&line, &policy, EXIT_POLICY_IPV6_ENABLED | EXIT_POLICY_ADD_DEFAULT ,0); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0);

summary = policy_summarize(policy, AF_INET);

tt_assert(summary != NULL); - tt_str_op(summary,==, expected_summary); + tt_str_op(summary,OP_EQ, expected_summary);

short_policy = parse_short_policy(summary); tt_assert(short_policy); summary_after = write_short_policy(short_policy); - tt_str_op(summary,==, summary_after); + tt_str_op(summary,OP_EQ, summary_after);

done: tor_free(summary_after); @@ -90,12 +90,12 @@ test_policies_general(void *arg)

p = router_parse_addr_policy_item_from_string("reject 192.168.0.0/16:*",-1); tt_assert(p != NULL); - tt_int_op(ADDR_POLICY_REJECT,==, p->policy_type); + tt_int_op(ADDR_POLICY_REJECT,OP_EQ, p->policy_type); tor_addr_from_ipv4h(&tar, 0xc0a80000u); - tt_int_op(0,==, tor_addr_compare(&p->addr, &tar, CMP_EXACT)); - tt_int_op(16,==, p->maskbits); - tt_int_op(1,==, p->prt_min); - tt_int_op(65535,==, p->prt_max); + tt_int_op(0,OP_EQ, tor_addr_compare(&p->addr, &tar, CMP_EXACT)); + tt_int_op(16,OP_EQ, p->maskbits); + tt_int_op(1,OP_EQ, p->prt_min); + tt_int_op(65535,OP_EQ, p->prt_max);

smartlist_add(policy, p);

@@ -109,7 +109,7 @@ test_policies_general(void *arg) tt_assert(ADDR_POLICY_REJECTED == compare_tor_addr_to_addr_policy(&tar, 2, policy));

- tt_int_op(0, ==, policies_parse_exit_policy(NULL, &policy2, + tt_int_op(0, OP_EQ, policies_parse_exit_policy(NULL, &policy2, EXIT_POLICY_IPV6_ENABLED | EXIT_POLICY_REJECT_PRIVATE | EXIT_POLICY_ADD_DEFAULT, 0)); @@ -200,14 +200,14 @@ test_policies_general(void *arg) line.key = (char*)"foo"; line.value = (char*)"accept *:80,reject private:*,reject *:*"; line.next = NULL; - tt_int_op(0, ==, policies_parse_exit_policy(&line,&policy, + tt_int_op(0, OP_EQ, policies_parse_exit_policy(&line,&policy, EXIT_POLICY_IPV6_ENABLED | EXIT_POLICY_ADD_DEFAULT,0)); tt_assert(policy);

//test_streq(policy->string, "accept *:80"); //test_streq(policy->next->string, "reject *:*"); - tt_int_op(smartlist_len(policy),==, 4); + tt_int_op(smartlist_len(policy),OP_EQ, 4);

/* test policy summaries */ /* check if we properly ignore private IP addresses */ @@ -281,7 +281,7 @@ test_policies_general(void *arg) /* Try parsing various broken short policies */ #define TT_BAD_SHORT_POLICY(s) \ do { \ - tt_ptr_op(NULL, ==, (short_parsed = parse_short_policy((s)))); \ + tt_ptr_op(NULL, OP_EQ, (short_parsed = parse_short_policy((s)))); \ } while (0) TT_BAD_SHORT_POLICY("accept 200-199"); TT_BAD_SHORT_POLICY(""); @@ -311,7 +311,7 @@ test_policies_general(void *arg) smartlist_free(chunks); short_parsed = parse_short_policy(policy);/* shouldn't be accepted */ tor_free(policy); - tt_ptr_op(NULL, ==, short_parsed); + tt_ptr_op(NULL, OP_EQ, short_parsed); }

/* truncation ports */ @@ -369,7 +369,7 @@ test_dump_exit_policy_to_string(void *arg) ri->exit_policy = NULL; // expecting "reject *:*" ep = router_dump_exit_policy_to_string(ri,1,1);

- tt_str_op("reject *:*",==, ep); + tt_str_op("reject *:*",OP_EQ, ep);

tor_free(ep);

@@ -382,7 +382,7 @@ test_dump_exit_policy_to_string(void *arg)

ep = router_dump_exit_policy_to_string(ri,1,1);

- tt_str_op("accept *:*",==, ep); + tt_str_op("accept *:*",OP_EQ, ep);

tor_free(ep);

@@ -392,7 +392,7 @@ test_dump_exit_policy_to_string(void *arg)

ep = router_dump_exit_policy_to_string(ri,1,1);

- tt_str_op("accept *:*\nreject *:25",==, ep); + tt_str_op("accept *:*\nreject *:25",OP_EQ, ep);

tor_free(ep);

@@ -403,7 +403,7 @@ test_dump_exit_policy_to_string(void *arg)

ep = router_dump_exit_policy_to_string(ri,1,1);

- tt_str_op("accept *:*\nreject *:25\nreject 8.8.8.8:*",==, ep); + tt_str_op("accept *:*\nreject *:25\nreject 8.8.8.8:*",OP_EQ, ep); tor_free(ep);

policy_entry = @@ -414,7 +414,7 @@ test_dump_exit_policy_to_string(void *arg) ep = router_dump_exit_policy_to_string(ri,1,1);

tt_str_op("accept *:*\nreject *:25\nreject 8.8.8.8:*\n" - "reject6 [fc00::]/7:*",==, ep); + "reject6 [fc00::]/7:*",OP_EQ, ep); tor_free(ep);

policy_entry = @@ -425,7 +425,7 @@ test_dump_exit_policy_to_string(void *arg) ep = router_dump_exit_policy_to_string(ri,1,1);

tt_str_op("accept *:*\nreject *:25\nreject 8.8.8.8:*\n" - "reject6 [fc00::]/7:*\naccept6 [c000::]/3:*",==, ep); + "reject6 [fc00::]/7:*\naccept6 [c000::]/3:*",OP_EQ, ep);

done:

diff --git a/src/test/test_pt.c b/src/test/test_pt.c index 1be52ee..dba880e 100644 --- a/src/test/test_pt.c +++ b/src/test/test_pt.c @@ -69,7 +69,7 @@ test_pt_parsing(void *arg) /* test registered SOCKS version of transport */ tt_assert(transport->socks_version == PROXY_SOCKS5); /* test registered name of transport */ - tt_str_op(transport->name,==, "trebuchet"); + tt_str_op(transport->name,OP_EQ, "trebuchet");

reset_mp(mp);

@@ -96,7 +96,7 @@ test_pt_parsing(void *arg) /* test registered port of transport */ tt_assert(transport->port == 2999); /* test registered name of transport */ - tt_str_op(transport->name,==, "trebuchy"); + tt_str_op(transport->name,OP_EQ, "trebuchy");

reset_mp(mp);

@@ -105,14 +105,14 @@ test_pt_parsing(void *arg) "ARGS:counterweight=3,sling=snappy", sizeof(line)); tt_assert(parse_smethod_line(line, mp) == 0); - tt_int_op(1, ==, smartlist_len(mp->transports)); + tt_int_op(1, OP_EQ, smartlist_len(mp->transports)); { const transport_t *transport = smartlist_get(mp->transports, 0); tt_assert(transport); - tt_str_op(transport->name, ==, "trebuchet"); - tt_int_op(transport->port, ==, 9999); - tt_str_op(fmt_addr(&transport->addr), ==, "127.0.0.1"); - tt_str_op(transport->extra_info_args, ==, + tt_str_op(transport->name, OP_EQ, "trebuchet"); + tt_int_op(transport->port, OP_EQ, 9999); + tt_str_op(fmt_addr(&transport->addr), OP_EQ, "127.0.0.1"); + tt_str_op(transport->extra_info_args, OP_EQ, "counterweight=3,sling=snappy"); } reset_mp(mp); @@ -151,9 +151,9 @@ test_pt_get_transport_options(void *arg) execve_args[1] = NULL;

mp = managed_proxy_create(transport_list, execve_args, 1); - tt_ptr_op(mp, !=, NULL); + tt_ptr_op(mp, OP_NE, NULL); opt_str = get_transport_options_for_server_proxy(mp); - tt_ptr_op(opt_str, ==, NULL); + tt_ptr_op(opt_str, OP_EQ, NULL);

smartlist_add(mp->transports_to_launch, tor_strdup("gruyere")); smartlist_add(mp->transports_to_launch, tor_strdup("roquefort")); @@ -176,7 +176,7 @@ test_pt_get_transport_options(void *arg) options->ServerTransportOptions = cl;

opt_str = get_transport_options_for_server_proxy(mp); - tt_str_op(opt_str, ==, + tt_str_op(opt_str, OP_EQ, "gruyere:melty=10;gruyere:hardness=se\;ven;" "stnectaire:melty=4;stnectaire:hardness=three");

@@ -262,17 +262,17 @@ test_pt_get_extrainfo_string(void *arg) mp2 = managed_proxy_create(t2, argv2, 1);

r = parse_smethod_line("SMETHOD hagbard 127.0.0.1:5555", mp1); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); r = parse_smethod_line("SMETHOD celine 127.0.0.1:1723 ARGS:card=no-enemy", mp2); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0);

/* Force these proxies to look "completed" or they won't generate output. */ mp1->conf_state = mp2->conf_state = PT_PROTO_COMPLETED;

s = pt_get_extra_info_descriptor_string(); tt_assert(s); - tt_str_op(s, ==, + tt_str_op(s, OP_EQ, "transport hagbard 127.0.0.1:5555\n" "transport celine 127.0.0.1:1723 card=no-enemy\n");

@@ -380,7 +380,7 @@ test_pt_configure_proxy(void *arg) for (i = 0 ; i < 5 ; i++) { retval = configure_proxy(mp); /* retval should be zero because proxy hasn't finished configuring yet */ - tt_int_op(retval, ==, 0); + tt_int_op(retval, OP_EQ, 0); /* check the number of registered transports */ tt_assert(smartlist_len(mp->transports) == i+1); /* check that the mp is still waiting for transports */ @@ -390,23 +390,23 @@ test_pt_configure_proxy(void *arg) /* this last configure_proxy() should finalize the proxy configuration. */ retval = configure_proxy(mp); /* retval should be 1 since the proxy finished configuring */ - tt_int_op(retval, ==, 1); + tt_int_op(retval, OP_EQ, 1); /* check the mp state */ tt_assert(mp->conf_state == PT_PROTO_COMPLETED);

- tt_int_op(controlevent_n, ==, 5); - tt_int_op(controlevent_event, ==, EVENT_TRANSPORT_LAUNCHED); - tt_int_op(smartlist_len(controlevent_msgs), ==, 5); + tt_int_op(controlevent_n, OP_EQ, 5); + tt_int_op(controlevent_event, OP_EQ, EVENT_TRANSPORT_LAUNCHED); + tt_int_op(smartlist_len(controlevent_msgs), OP_EQ, 5); smartlist_sort_strings(controlevent_msgs); - tt_str_op(smartlist_get(controlevent_msgs, 0), ==, + tt_str_op(smartlist_get(controlevent_msgs, 0), OP_EQ, "650 TRANSPORT_LAUNCHED server mock1 127.0.0.1 5551\r\n"); - tt_str_op(smartlist_get(controlevent_msgs, 1), ==, + tt_str_op(smartlist_get(controlevent_msgs, 1), OP_EQ, "650 TRANSPORT_LAUNCHED server mock2 127.0.0.1 5552\r\n"); - tt_str_op(smartlist_get(controlevent_msgs, 2), ==, + tt_str_op(smartlist_get(controlevent_msgs, 2), OP_EQ, "650 TRANSPORT_LAUNCHED server mock3 127.0.0.1 5553\r\n"); - tt_str_op(smartlist_get(controlevent_msgs, 3), ==, + tt_str_op(smartlist_get(controlevent_msgs, 3), OP_EQ, "650 TRANSPORT_LAUNCHED server mock4 127.0.0.1 5554\r\n"); - tt_str_op(smartlist_get(controlevent_msgs, 4), ==, + tt_str_op(smartlist_get(controlevent_msgs, 4), OP_EQ, "650 TRANSPORT_LAUNCHED server mock5 127.0.0.1 5555\r\n");

{ /* check that the transport info were saved properly in the tor state */ @@ -423,8 +423,8 @@ test_pt_configure_proxy(void *arg) NULL, 0, 0); name_of_transport = smartlist_get(transport_info_sl, 0); bindaddr = smartlist_get(transport_info_sl, 1); - tt_str_op(name_of_transport, ==, "mock1"); - tt_str_op(bindaddr, ==, "127.0.0.1:5551"); + tt_str_op(name_of_transport, OP_EQ, "mock1"); + tt_str_op(bindaddr, OP_EQ, "127.0.0.1:5551");

SMARTLIST_FOREACH(transport_info_sl, char *, cp, tor_free(cp)); smartlist_free(transport_info_sl); @@ -470,9 +470,9 @@ test_get_pt_proxy_uri(void *arg) ret = tor_addr_port_lookup(options->Socks4Proxy, &options->Socks4ProxyAddr, &options->Socks4ProxyPort); - tt_int_op(ret, ==, 0); + tt_int_op(ret, OP_EQ, 0); uri = get_pt_proxy_uri(); - tt_str_op(uri, ==, "socks4a://192.0.2.1:1080"); + tt_str_op(uri, OP_EQ, "socks4a://192.0.2.1:1080"); tor_free(uri); tor_free(options->Socks4Proxy);

@@ -481,16 +481,16 @@ test_get_pt_proxy_uri(void *arg) ret = tor_addr_port_lookup(options->Socks5Proxy, &options->Socks5ProxyAddr, &options->Socks5ProxyPort); - tt_int_op(ret, ==, 0); + tt_int_op(ret, OP_EQ, 0); uri = get_pt_proxy_uri(); - tt_str_op(uri, ==, "socks5://192.0.2.1:1080"); + tt_str_op(uri, OP_EQ, "socks5://192.0.2.1:1080"); tor_free(uri);

/* Test with a SOCKS5 proxy, with username/password. */ options->Socks5ProxyUsername = tor_strdup("hwest"); options->Socks5ProxyPassword = tor_strdup("r34n1m470r"); uri = get_pt_proxy_uri(); - tt_str_op(uri, ==, "socks5://hwest:r34n1m470r@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);

diff --git a/src/test/test_relaycell.c b/src/test/test_relaycell.c index 5deb362..834dfef 100644 --- a/src/test/test_relaycell.c +++ b/src/test/test_relaycell.c @@ -87,24 +87,24 @@ test_relaycell_resolved(void *arg) srm_ncalls = mum_ncalls = 0; \ } while (0) #define ASSERT_MARK_CALLED(reason) do { \ - tt_int_op(mum_ncalls, ==, 1); \ - tt_ptr_op(mum_conn, ==, entryconn); \ - tt_int_op(mum_endreason, ==, (reason)); \ + tt_int_op(mum_ncalls, OP_EQ, 1); \ + tt_ptr_op(mum_conn, OP_EQ, entryconn); \ + tt_int_op(mum_endreason, OP_EQ, (reason)); \ } while (0) #define ASSERT_RESOLVED_CALLED(atype, answer, ttl, expires) do { \ - tt_int_op(srm_ncalls, ==, 1); \ - tt_ptr_op(srm_conn, ==, entryconn); \ - tt_int_op(srm_atype, ==, (atype)); \ + tt_int_op(srm_ncalls, OP_EQ, 1); \ + tt_ptr_op(srm_conn, OP_EQ, entryconn); \ + tt_int_op(srm_atype, OP_EQ, (atype)); \ if (answer) { \ - tt_int_op(srm_alen, ==, sizeof(answer)-1); \ - tt_int_op(srm_alen, <, 512); \ - tt_int_op(srm_answer_is_set, ==, 1); \ - tt_mem_op(srm_answer, ==, answer, sizeof(answer)-1); \ + tt_int_op(srm_alen, OP_EQ, sizeof(answer)-1); \ + tt_int_op(srm_alen, OP_LT, 512); \ + tt_int_op(srm_answer_is_set, OP_EQ, 1); \ + tt_mem_op(srm_answer, OP_EQ, answer, sizeof(answer)-1); \ } else { \ - tt_int_op(srm_answer_is_set, ==, 0); \ + tt_int_op(srm_answer_is_set, OP_EQ, 0); \ } \ - tt_int_op(srm_ttl, ==, ttl); \ - tt_int_op(srm_expires, ==, expires); \ + tt_int_op(srm_ttl, OP_EQ, ttl); \ + tt_int_op(srm_expires, OP_EQ, expires); \ } while (0)

(void)arg; @@ -130,9 +130,9 @@ test_relaycell_resolved(void *arg) /* Try with connection in non-RESOLVE_WAIT state: cell gets ignored */ MOCK_RESET(); r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh); - tt_int_op(r, ==, 0); - tt_int_op(srm_ncalls, ==, 0); - tt_int_op(mum_ncalls, ==, 0); + tt_int_op(r, OP_EQ, 0); + tt_int_op(srm_ncalls, OP_EQ, 0); + tt_int_op(mum_ncalls, OP_EQ, 0);

/* Now put it in the right state. */ ENTRY_TO_CONN(entryconn)->state = AP_CONN_STATE_RESOLVE_WAIT; @@ -144,7 +144,7 @@ test_relaycell_resolved(void *arg) /* We prefer ipv4, so we should get the first ipv4 answer */ MOCK_RESET(); r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); ASSERT_MARK_CALLED(END_STREAM_REASON_DONE| END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED); ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_IPV4, "\x7f\x00\x01\x02", 256, -1); @@ -153,7 +153,7 @@ test_relaycell_resolved(void *arg) MOCK_RESET(); options->ClientDNSRejectInternalAddresses = 1; r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); ASSERT_MARK_CALLED(END_STREAM_REASON_DONE| END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED); ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_IPV4, "\x12\x00\x00\x01", 512, -1); @@ -162,7 +162,7 @@ test_relaycell_resolved(void *arg) entryconn->prefer_ipv6_traffic = 1; MOCK_RESET(); r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); ASSERT_MARK_CALLED(END_STREAM_REASON_DONE| END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED); ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_IPV6, @@ -174,7 +174,7 @@ test_relaycell_resolved(void *arg) MOCK_RESET(); SET_CELL("\x04\x04\x12\x00\x00\x01\x00\x00\x02\x00"); r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); ASSERT_MARK_CALLED(END_STREAM_REASON_DONE| END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED); ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_IPV4, "\x12\x00\x00\x01", 512, -1); @@ -184,7 +184,7 @@ test_relaycell_resolved(void *arg) MOCK_RESET(); entryconn->ipv4_traffic_ok = 0; r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); ASSERT_MARK_CALLED(END_STREAM_REASON_DONE| END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED); ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_ERROR, NULL, -1, -1); @@ -194,7 +194,7 @@ test_relaycell_resolved(void *arg) entryconn->ipv4_traffic_ok = 1; entryconn->socks_request->command = SOCKS_COMMAND_RESOLVE_PTR; r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); ASSERT_MARK_CALLED(END_STREAM_REASON_DONE| END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED); ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_ERROR, NULL, -1, -1); @@ -203,7 +203,7 @@ test_relaycell_resolved(void *arg) MOCK_RESET(); SET_CELL("\x00\x0fwww.example.com\x00\x01\x00\x00"); r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); ASSERT_MARK_CALLED(END_STREAM_REASON_DONE| END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED); ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_HOSTNAME, "www.example.com", 65536, -1); @@ -213,9 +213,9 @@ test_relaycell_resolved(void *arg) entryconn->socks_request->command = SOCKS_COMMAND_RESOLVE; SET_CELL("\x04\x04\x01\x02\x03\x04"); /* no ttl */ r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); ASSERT_MARK_CALLED(END_STREAM_REASON_TORPROTOCOL); - tt_int_op(srm_ncalls, ==, 0); + tt_int_op(srm_ncalls, OP_EQ, 0);

/* error on all addresses private */ MOCK_RESET(); @@ -224,7 +224,7 @@ test_relaycell_resolved(void *arg) /* IPv4: 192.168.1.1, ttl 256 */ "\x04\x04\xc0\xa8\x01\x01\x00\x00\x01\x00"); r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); ASSERT_MARK_CALLED(END_STREAM_REASON_TORPROTOCOL); ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_ERROR_TRANSIENT, NULL, 0, TIME_MAX);

@@ -232,7 +232,7 @@ test_relaycell_resolved(void *arg) MOCK_RESET(); SET_CELL("\xf0\x15" "quiet and meaningless" "\x00\x00\x0f\xff"); r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); ASSERT_MARK_CALLED(END_STREAM_REASON_DONE| END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED); ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_ERROR_TRANSIENT, NULL, -1, -1); diff --git a/src/test/test_replay.c b/src/test/test_replay.c index bb8017d..b1f637a 100644 --- a/src/test/test_replay.c +++ b/src/test/test_replay.c @@ -44,7 +44,7 @@ test_replaycache_badalloc(void *arg) /* Negative interval should get adjusted to zero */ r = replaycache_new(600, -300); tt_assert(r != NULL); - tt_int_op(r->scrub_interval,==, 0); + tt_int_op(r->scrub_interval,OP_EQ, 0); replaycache_free(r); /* Negative horizon and negative interval should still fail */ r = replaycache_new(-600, -300); @@ -81,13 +81,13 @@ test_replaycache_miss(void *arg) result = replaycache_add_and_test_internal(1200, r, test_buffer, strlen(test_buffer), NULL); - tt_int_op(result,==, 0); + tt_int_op(result,OP_EQ, 0);

/* poke the bad-parameter error case too */ result = replaycache_add_and_test_internal(1200, NULL, test_buffer, strlen(test_buffer), NULL); - tt_int_op(result,==, 0); + tt_int_op(result,OP_EQ, 0);

done: if (r) replaycache_free(r); @@ -108,12 +108,12 @@ test_replaycache_hit(void *arg) result = replaycache_add_and_test_internal(1200, r, test_buffer, strlen(test_buffer), NULL); - tt_int_op(result,==, 0); + tt_int_op(result,OP_EQ, 0);

result = replaycache_add_and_test_internal(1300, r, test_buffer, strlen(test_buffer), NULL); - tt_int_op(result,==, 1); + tt_int_op(result,OP_EQ, 1);

done: if (r) replaycache_free(r); @@ -134,17 +134,17 @@ test_replaycache_age(void *arg) result = replaycache_add_and_test_internal(1200, r, test_buffer, strlen(test_buffer), NULL); - tt_int_op(result,==, 0); + tt_int_op(result,OP_EQ, 0);

result = replaycache_add_and_test_internal(1300, r, test_buffer, strlen(test_buffer), NULL); - tt_int_op(result,==, 1); + tt_int_op(result,OP_EQ, 1);

result = replaycache_add_and_test_internal(3000, r, test_buffer, strlen(test_buffer), NULL); - tt_int_op(result,==, 0); + tt_int_op(result,OP_EQ, 0);

done: if (r) replaycache_free(r); @@ -166,13 +166,13 @@ test_replaycache_elapsed(void *arg) result = replaycache_add_and_test_internal(1200, r, test_buffer, strlen(test_buffer), NULL); - tt_int_op(result,==, 0); + tt_int_op(result,OP_EQ, 0);

result = replaycache_add_and_test_internal(1300, r, test_buffer, strlen(test_buffer), &elapsed); - tt_int_op(result,==, 1); - tt_int_op(elapsed,==, 100); + tt_int_op(result,OP_EQ, 1); + tt_int_op(elapsed,OP_EQ, 100);

done: if (r) replaycache_free(r); @@ -193,17 +193,17 @@ test_replaycache_noexpire(void *arg) result = replaycache_add_and_test_internal(1200, r, test_buffer, strlen(test_buffer), NULL); - tt_int_op(result,==, 0); + tt_int_op(result,OP_EQ, 0);

result = replaycache_add_and_test_internal(1300, r, test_buffer, strlen(test_buffer), NULL); - tt_int_op(result,==, 1); + tt_int_op(result,OP_EQ, 1);

result = replaycache_add_and_test_internal(3000, r, test_buffer, strlen(test_buffer), NULL); - tt_int_op(result,==, 1); + tt_int_op(result,OP_EQ, 1);

done: if (r) replaycache_free(r); @@ -225,12 +225,12 @@ test_replaycache_scrub(void *arg) result = replaycache_add_and_test_internal(100, r, test_buffer, strlen(test_buffer), NULL); - tt_int_op(result,==, 0); + tt_int_op(result,OP_EQ, 0);

result = replaycache_add_and_test_internal(200, r, test_buffer, strlen(test_buffer), NULL); - tt_int_op(result,==, 1); + tt_int_op(result,OP_EQ, 1);

/* * Poke a few replaycache_scrub_if_needed_internal() error cases that @@ -245,7 +245,7 @@ test_replaycache_scrub(void *arg) /* Make sure we hit the aging-out case too */ replaycache_scrub_if_needed_internal(1500, r); /* Assert that we aged it */ - tt_int_op(digestmap_size(r->digests_seen),==, 0); + tt_int_op(digestmap_size(r->digests_seen),OP_EQ, 0);

done: if (r) replaycache_free(r); @@ -268,16 +268,16 @@ test_replaycache_future(void *arg) result = replaycache_add_and_test_internal(100, r, test_buffer, strlen(test_buffer), &elapsed); - tt_int_op(result,==, 0); + tt_int_op(result,OP_EQ, 0); /* elapsed should still be 0, since it wasn't written */ - tt_int_op(elapsed,==, 0); + tt_int_op(elapsed,OP_EQ, 0);

result = replaycache_add_and_test_internal(200, r, test_buffer, strlen(test_buffer), &elapsed); - tt_int_op(result,==, 1); + tt_int_op(result,OP_EQ, 1); /* elapsed should be the time since the last hit */ - tt_int_op(elapsed,==, 100); + tt_int_op(elapsed,OP_EQ, 100);

/* * Now let's turn the clock back to get coverage on the cache entry from the @@ -287,9 +287,9 @@ test_replaycache_future(void *arg) replaycache_add_and_test_internal(150, r, test_buffer, strlen(test_buffer), &elapsed); /* We should still get a hit */ - tt_int_op(result,==, 1); + tt_int_op(result,OP_EQ, 1); /* ...but it shouldn't let us see a negative elapsed time */ - tt_int_op(elapsed,==, 0); + tt_int_op(elapsed,OP_EQ, 0);

done: if (r) replaycache_free(r); @@ -316,18 +316,18 @@ test_replaycache_realtime(void *arg) /* This should miss */ result = replaycache_add_and_test(r, test_buffer, strlen(test_buffer)); - tt_int_op(result,==, 0); + tt_int_op(result,OP_EQ, 0);

/* This should hit */ result = replaycache_add_and_test(r, test_buffer, strlen(test_buffer)); - tt_int_op(result,==, 1); + tt_int_op(result,OP_EQ, 1);

/* This should hit and return a small elapsed time */ result = replaycache_add_test_and_elapsed(r, test_buffer, strlen(test_buffer), &elapsed); - tt_int_op(result,==, 1); + tt_int_op(result,OP_EQ, 1); tt_assert(elapsed >= 0); tt_assert(elapsed <= 5);

diff --git a/src/test/test_routerkeys.c b/src/test/test_routerkeys.c index 652d7d6..d8ad59a 100644 --- a/src/test/test_routerkeys.c +++ b/src/test/test_routerkeys.c @@ -33,38 +33,38 @@ test_routerkeys_write_fingerprint(void *arg) set_server_identity_key(key); set_client_identity_key(crypto_pk_dup_key(key));

- tt_int_op(0, ==, check_private_dir(ddir, CPD_CREATE, NULL)); - tt_int_op(crypto_pk_cmp_keys(get_server_identity_key(),key),==,0); + tt_int_op(0, OP_EQ, check_private_dir(ddir, CPD_CREATE, NULL)); + tt_int_op(crypto_pk_cmp_keys(get_server_identity_key(),key),OP_EQ,0);

/* Write fingerprint file */ - tt_int_op(0, ==, router_write_fingerprint(0)); + tt_int_op(0, OP_EQ, router_write_fingerprint(0)); cp = read_file_to_str(get_fname("write_fingerprint/fingerprint"), 0, NULL); crypto_pk_get_fingerprint(key, fp, 0); tor_asprintf(&cp2, "haflinger %s\n", fp); - tt_str_op(cp, ==, cp2); + tt_str_op(cp, OP_EQ, cp2); tor_free(cp); tor_free(cp2);

/* Write hashed-fingerprint file */ - tt_int_op(0, ==, router_write_fingerprint(1)); + tt_int_op(0, OP_EQ, router_write_fingerprint(1)); cp = read_file_to_str(get_fname("write_fingerprint/hashed-fingerprint"), 0, NULL); crypto_pk_get_hashed_fingerprint(key, fp); tor_asprintf(&cp2, "haflinger %s\n", fp); - tt_str_op(cp, ==, cp2); + tt_str_op(cp, OP_EQ, cp2); tor_free(cp); tor_free(cp2);

/* Replace outdated file */ write_str_to_file(get_fname("write_fingerprint/hashed-fingerprint"), "junk goes here", 0); - tt_int_op(0, ==, router_write_fingerprint(1)); + tt_int_op(0, OP_EQ, router_write_fingerprint(1)); cp = read_file_to_str(get_fname("write_fingerprint/hashed-fingerprint"), 0, NULL); crypto_pk_get_hashed_fingerprint(key, fp); tor_asprintf(&cp2, "haflinger %s\n", fp); - tt_str_op(cp, ==, cp2); + tt_str_op(cp, OP_EQ, cp2); tor_free(cp); tor_free(cp2);

diff --git a/src/test/test_routerset.c b/src/test/test_routerset.c index 81e4dbb..9bd0c12 100644 --- a/src/test/test_routerset.c +++ b/src/test/test_routerset.c @@ -25,12 +25,12 @@ NS(test_main)(void *arg)

rs = routerset_new();

- tt_ptr_op(rs, !=, NULL); - tt_ptr_op(rs->list, !=, NULL); - tt_ptr_op(rs->names, !=, NULL); - tt_ptr_op(rs->digests, !=, NULL); - tt_ptr_op(rs->policies, !=, NULL); - tt_ptr_op(rs->country_names, !=, NULL); + tt_ptr_op(rs, OP_NE, NULL); + tt_ptr_op(rs->list, OP_NE, NULL); + tt_ptr_op(rs->names, OP_NE, NULL); + tt_ptr_op(rs->digests, OP_NE, NULL); + tt_ptr_op(rs->policies, OP_NE, NULL); + tt_ptr_op(rs->country_names, OP_NE, NULL);

done: routerset_free(rs); @@ -53,30 +53,30 @@ NS(test_main)(void *arg) /* strlen(c) < 4 */ input = "xxx"; name = routerset_get_countryname(input); - tt_ptr_op(name, ==, NULL); + tt_ptr_op(name, OP_EQ, NULL); tor_free(name);

/* c[0] != '{' */ input = "xxx}"; name = routerset_get_countryname(input); - tt_ptr_op(name, ==, NULL); + tt_ptr_op(name, OP_EQ, NULL); tor_free(name);

/* c[3] != '}' */ input = "{xxx"; name = routerset_get_countryname(input); - tt_ptr_op(name, ==, NULL); + tt_ptr_op(name, OP_EQ, NULL); tor_free(name);

/* tor_strlower */ input = "{XX}"; name = routerset_get_countryname(input); - tt_str_op(name, ==, "xx"); + tt_str_op(name, OP_EQ, "xx"); tor_free(name);

input = "{xx}"; name = routerset_get_countryname(input); - tt_str_op(name, ==, "xx"); + tt_str_op(name, OP_EQ, "xx"); done: tor_free(name); } @@ -103,10 +103,10 @@ NS(test_main)(void *arg)

routerset_refresh_countries(set);

- tt_ptr_op(set->countries, ==, NULL); - tt_int_op(set->n_countries, ==, 0); - tt_int_op(CALLED(geoip_is_loaded), ==, 1); - tt_int_op(CALLED(geoip_get_n_countries), ==, 0); + tt_ptr_op(set->countries, OP_EQ, NULL); + tt_int_op(set->n_countries, OP_EQ, 0); + tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1); + tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 0);

done: NS_UNMOCK(geoip_is_loaded); @@ -154,12 +154,12 @@ NS(test_main)(void *arg)

routerset_refresh_countries(set);

- tt_ptr_op(set->countries, !=, NULL); - tt_int_op(set->n_countries, ==, 1); - tt_int_op((unsigned int)(*set->countries), ==, 0); - tt_int_op(CALLED(geoip_is_loaded), ==, 1); - tt_int_op(CALLED(geoip_get_n_countries), ==, 1); - tt_int_op(CALLED(geoip_get_country), ==, 0); + tt_ptr_op(set->countries, OP_NE, NULL); + tt_int_op(set->n_countries, OP_EQ, 1); + tt_int_op((unsigned int)(*set->countries), OP_EQ, 0); + tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1); + tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 1); + tt_int_op(CALLED(geoip_get_country), OP_EQ, 0);

done: NS_UNMOCK(geoip_is_loaded); @@ -218,12 +218,12 @@ NS(test_main)(void *arg)

routerset_refresh_countries(set);

- tt_ptr_op(set->countries, !=, NULL); - tt_int_op(set->n_countries, ==, 2); - tt_int_op(CALLED(geoip_is_loaded), ==, 1); - tt_int_op(CALLED(geoip_get_n_countries), ==, 1); - tt_int_op(CALLED(geoip_get_country), ==, 1); - tt_int_op((unsigned int)(*set->countries), !=, 0); + tt_ptr_op(set->countries, OP_NE, NULL); + tt_int_op(set->n_countries, OP_EQ, 2); + tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1); + tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 1); + tt_int_op(CALLED(geoip_get_country), OP_EQ, 1); + tt_int_op((unsigned int)(*set->countries), OP_NE, 0);

done: NS_UNMOCK(geoip_is_loaded); @@ -283,12 +283,12 @@ NS(test_main)(void *arg)

routerset_refresh_countries(set);

- tt_ptr_op(set->countries, !=, NULL); - tt_int_op(set->n_countries, ==, 2); - tt_int_op(CALLED(geoip_is_loaded), ==, 1); - tt_int_op(CALLED(geoip_get_n_countries), ==, 1); - tt_int_op(CALLED(geoip_get_country), ==, 1); - tt_int_op((unsigned int)(*set->countries), ==, 0); + tt_ptr_op(set->countries, OP_NE, NULL); + tt_int_op(set->n_countries, OP_EQ, 2); + tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1); + tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 1); + tt_int_op(CALLED(geoip_get_country), OP_EQ, 1); + tt_int_op((unsigned int)(*set->countries), OP_EQ, 0);

done: NS_UNMOCK(geoip_is_loaded); @@ -340,7 +340,7 @@ NS(test_main)(void *arg)

r = routerset_parse(set, s, "");

- tt_int_op(r, ==, -1); + tt_int_op(r, OP_EQ, -1);

done: routerset_free(set); @@ -365,8 +365,8 @@ NS(test_main)(void *arg) set = routerset_new(); s = "$0000000000000000000000000000000000000000"; r = routerset_parse(set, s, ""); - tt_int_op(r, ==, 0); - tt_int_op(digestmap_isempty(set->digests), !=, 1); + tt_int_op(r, OP_EQ, 0); + tt_int_op(digestmap_isempty(set->digests), OP_NE, 1);

done: routerset_free(set); @@ -390,8 +390,8 @@ NS(test_main)(void *arg) set = routerset_new(); s = "fred"; r = routerset_parse(set, s, ""); - tt_int_op(r, ==, 0); - tt_int_op(strmap_isempty(set->names), !=, 1); + tt_int_op(r, OP_EQ, 0); + tt_int_op(strmap_isempty(set->names), OP_NE, 1);

done: routerset_free(set); @@ -415,8 +415,8 @@ NS(test_main)(void *arg) set = routerset_new(); s = "{cc}"; r = routerset_parse(set, s, ""); - tt_int_op(r, ==, 0); - tt_int_op(smartlist_len(set->country_names), !=, 0); + tt_int_op(r, OP_EQ, 0); + tt_int_op(smartlist_len(set->country_names), OP_NE, 0);

done: routerset_free(set); @@ -448,9 +448,9 @@ NS(test_main)(void *arg) set = routerset_new(); s = "*"; r = routerset_parse(set, s, ""); - tt_int_op(r, ==, 0); - tt_int_op(smartlist_len(set->policies), !=, 0); - tt_int_op(CALLED(router_parse_addr_policy_item_from_string), ==, 1); + tt_int_op(r, OP_EQ, 0); + tt_int_op(smartlist_len(set->policies), OP_NE, 0); + tt_int_op(CALLED(router_parse_addr_policy_item_from_string), OP_EQ, 1);

done: routerset_free(set); @@ -489,10 +489,10 @@ NS(test_main)(void *arg) NS_MOCK(smartlist_new);

routerset_union(set, NULL); - tt_int_op(CALLED(smartlist_new), ==, 0); + tt_int_op(CALLED(smartlist_new), OP_EQ, 0);

routerset_union(set, bad_set); - tt_int_op(CALLED(smartlist_new), ==, 0); + tt_int_op(CALLED(smartlist_new), OP_EQ, 0);

done: NS_UNMOCK(smartlist_new); @@ -529,7 +529,7 @@ NS(test_main)(void *arg) smartlist_add(src->list, tor_strdup("{xx}")); routerset_union(tgt, src);

- tt_int_op(smartlist_len(tgt->list), !=, 0); + tt_int_op(smartlist_len(tgt->list), OP_NE, 0);

done: routerset_free(src); @@ -556,7 +556,7 @@ NS(test_main)(void *arg) is_list = routerset_is_list(set); routerset_free(set); set = NULL; - tt_int_op(is_list, !=, 0); + tt_int_op(is_list, OP_NE, 0);

/* len(set->country_names) != 0, len(set->policies) == 0 */ set = routerset_new(); @@ -564,7 +564,7 @@ NS(test_main)(void *arg) is_list = routerset_is_list(set); routerset_free(set); set = NULL; - tt_int_op(is_list, ==, 0); + tt_int_op(is_list, OP_EQ, 0);

/* len(set->country_names) == 0, len(set->policies) != 0 */ set = routerset_new(); @@ -573,7 +573,7 @@ NS(test_main)(void *arg) is_list = routerset_is_list(set); routerset_free(set); set = NULL; - tt_int_op(is_list, ==, 0); + tt_int_op(is_list, OP_EQ, 0);

/* len(set->country_names) != 0, len(set->policies) != 0 */ set = routerset_new(); @@ -583,7 +583,7 @@ NS(test_main)(void *arg) is_list = routerset_is_list(set); routerset_free(set); set = NULL; - tt_int_op(is_list, ==, 0); + tt_int_op(is_list, OP_EQ, 0);

done: ; @@ -605,12 +605,12 @@ NS(test_main)(void *arg)

set = NULL; needs_geoip = routerset_needs_geoip(set); - tt_int_op(needs_geoip, ==, 0); + tt_int_op(needs_geoip, OP_EQ, 0);

set = routerset_new(); needs_geoip = routerset_needs_geoip(set); routerset_free((routerset_t *)set); - tt_int_op(needs_geoip, ==, 0); + tt_int_op(needs_geoip, OP_EQ, 0); set = NULL;

set = routerset_new(); @@ -618,7 +618,7 @@ NS(test_main)(void *arg) needs_geoip = routerset_needs_geoip(set); routerset_free((routerset_t *)set); set = NULL; - tt_int_op(needs_geoip, !=, 0); + tt_int_op(needs_geoip, OP_NE, 0);

done: ; @@ -639,20 +639,20 @@ NS(test_main)(void *arg) (void)arg;

is_empty = routerset_is_empty(set); - tt_int_op(is_empty, !=, 0); + tt_int_op(is_empty, OP_NE, 0);

set = routerset_new(); is_empty = routerset_is_empty(set); routerset_free(set); set = NULL; - tt_int_op(is_empty, !=, 0); + tt_int_op(is_empty, OP_NE, 0);

set = routerset_new(); smartlist_add(set->list, tor_strdup("{xx}")); is_empty = routerset_is_empty(set); routerset_free(set); set = NULL; - tt_int_op(is_empty, ==, 0); + tt_int_op(is_empty, OP_EQ, 0);

done: ; @@ -675,13 +675,13 @@ NS(test_main)(void *arg)

contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);

- tt_int_op(contains, ==, 0); + tt_int_op(contains, OP_EQ, 0);

set = tor_malloc_zero(sizeof(routerset_t)); set->list = NULL; contains = routerset_contains(set, NULL, 0, NULL, NULL, 0); tor_free(set); - tt_int_op(contains, ==, 0); + tt_int_op(contains, OP_EQ, 0);

done: ; @@ -706,7 +706,7 @@ NS(test_main)(void *arg) contains = routerset_contains(set, NULL, 0, nickname, NULL, 0); routerset_free(set);

- tt_int_op(contains, ==, 0); + tt_int_op(contains, OP_EQ, 0);

done: ; @@ -733,7 +733,7 @@ NS(test_main)(void *arg) contains = routerset_contains(set, NULL, 0, nickname, NULL, 0); routerset_free(set);

- tt_int_op(contains, ==, 4); + tt_int_op(contains, OP_EQ, 4); done: ; } @@ -757,7 +757,7 @@ NS(test_main)(void *arg) contains = routerset_contains(set, NULL, 0, "foo", NULL, 0); routerset_free(set);

- tt_int_op(contains, ==, 0); + tt_int_op(contains, OP_EQ, 0); done: ; } @@ -782,7 +782,7 @@ NS(test_main)(void *arg) contains = routerset_contains(set, NULL, 0, NULL, (const char*)foo, 0); routerset_free(set);

- tt_int_op(contains, ==, 4); + tt_int_op(contains, OP_EQ, 4); done: ; } @@ -808,7 +808,7 @@ NS(test_main)(void *arg) contains = routerset_contains(set, NULL, 0, NULL, (const char*)foo, 0); routerset_free(set);

- tt_int_op(contains, ==, 0); + tt_int_op(contains, OP_EQ, 0); done: ; } @@ -833,7 +833,7 @@ NS(test_main)(void *arg) contains = routerset_contains(set, NULL, 0, NULL, NULL, 0); routerset_free(set);

- tt_int_op(contains, ==, 0); + tt_int_op(contains, OP_EQ, 0); done: ; } @@ -865,8 +865,8 @@ NS(test_main)(void *arg) contains = routerset_contains(set, addr, 0, NULL, NULL, 0); routerset_free(set);

- tt_int_op(CALLED(compare_tor_addr_to_addr_policy), ==, 1); - tt_int_op(contains, ==, 3); + tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1); + tt_int_op(contains, OP_EQ, 3);

done: ; @@ -879,7 +879,7 @@ NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port, (void)port; (void)policy; CALLED(compare_tor_addr_to_addr_policy)++; - tt_ptr_op(addr, ==, MOCK_TOR_ADDR_PTR); + tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR); return ADDR_POLICY_REJECTED;

done: @@ -910,8 +910,8 @@ NS(test_main)(void *arg) contains = routerset_contains(set, addr, 0, NULL, NULL, 0); routerset_free(set);

- tt_int_op(CALLED(compare_tor_addr_to_addr_policy), ==, 1); - tt_int_op(contains, ==, 0); + tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1); + tt_int_op(contains, OP_EQ, 0);

done: ; @@ -924,7 +924,7 @@ NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port, (void)port; (void)policy; CALLED(compare_tor_addr_to_addr_policy)++; - tt_ptr_op(addr, ==, MOCK_TOR_ADDR_PTR); + tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);

return ADDR_POLICY_ACCEPTED;

@@ -955,7 +955,7 @@ NS(test_main)(void *arg) contains = routerset_contains(set, NULL, 0, NULL, NULL, 0); routerset_free(set);

- tt_int_op(contains, ==, 0); + tt_int_op(contains, OP_EQ, 0);

done: ; @@ -968,7 +968,7 @@ NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port, (void)port; (void)policy; CALLED(compare_tor_addr_to_addr_policy)++; - tt_ptr_op(addr, ==, MOCK_TOR_ADDR_PTR); + tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);

return ADDR_POLICY_ACCEPTED;

@@ -1003,9 +1003,9 @@ NS(test_main)(void *arg) contains = routerset_contains(set, MOCK_TOR_ADDR_PTR, 0, NULL, NULL, -1); routerset_free(set);

- tt_int_op(contains, ==, 0); - tt_int_op(CALLED(compare_tor_addr_to_addr_policy), ==, 1); - tt_int_op(CALLED(geoip_get_country_by_addr), ==, 1); + tt_int_op(contains, OP_EQ, 0); + tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1); + tt_int_op(CALLED(geoip_get_country_by_addr), OP_EQ, 1);

done: ; @@ -1018,7 +1018,7 @@ NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port, (void)port; (void)policy; CALLED(compare_tor_addr_to_addr_policy)++; - tt_ptr_op(addr, ==, MOCK_TOR_ADDR_PTR); + tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);

done: return ADDR_POLICY_ACCEPTED; @@ -1028,7 +1028,7 @@ int NS(geoip_get_country_by_addr)(const tor_addr_t *addr) { CALLED(geoip_get_country_by_addr)++; - tt_ptr_op(addr, ==, MOCK_TOR_ADDR_PTR); + tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);

done: return -1; @@ -1062,9 +1062,9 @@ NS(test_main)(void *arg) contains = routerset_contains(set, MOCK_TOR_ADDR_PTR, 0, NULL, NULL, -1); routerset_free(set);

- tt_int_op(contains, ==, 2); - tt_int_op(CALLED(compare_tor_addr_to_addr_policy), ==, 1); - tt_int_op(CALLED(geoip_get_country_by_addr), ==, 1); + tt_int_op(contains, OP_EQ, 2); + tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1); + tt_int_op(CALLED(geoip_get_country_by_addr), OP_EQ, 1);

done: ; @@ -1077,7 +1077,7 @@ NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port, (void)port; (void)policy; CALLED(compare_tor_addr_to_addr_policy)++; - tt_ptr_op(addr, ==, MOCK_TOR_ADDR_PTR); + tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);

done: return ADDR_POLICY_ACCEPTED; @@ -1087,7 +1087,7 @@ int NS(geoip_get_country_by_addr)(const tor_addr_t *addr) { CALLED(geoip_get_country_by_addr)++; - tt_ptr_op(addr, ==, MOCK_TOR_ADDR_PTR); + tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);

done: return 1; @@ -1111,7 +1111,7 @@ NS(test_main)(void *arg)

r = routerset_add_unknown_ccs(setp, 1);

- tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0);

done: routerset_free(set); @@ -1140,8 +1140,8 @@ NS(test_main)(void *arg)

r = routerset_add_unknown_ccs(setp, 0);

- tt_ptr_op(*setp, !=, NULL); - tt_int_op(r, ==, 0); + tt_ptr_op(*setp, OP_NE, NULL); + tt_int_op(r, OP_EQ, 0);

done: if (set != NULL) @@ -1181,9 +1181,9 @@ NS(test_main)(void *arg)

r = routerset_add_unknown_ccs(setp, 0);

- tt_int_op(r, ==, 1); - tt_int_op(smartlist_contains_string(set->country_names, "??"), ==, 1); - tt_int_op(smartlist_contains_string(set->list, "{??}"), ==, 1); + tt_int_op(r, OP_EQ, 1); + tt_int_op(smartlist_contains_string(set->country_names, "??"), OP_EQ, 1); + tt_int_op(smartlist_contains_string(set->list, "{??}"), OP_EQ, 1);

done: if (set != NULL) @@ -1200,7 +1200,7 @@ NS(geoip_get_country)(const char *country) arg_is_qq = !strcmp(country, "??"); arg_is_a1 = !strcmp(country, "A1");

- tt_int_op(arg_is_qq || arg_is_a1, ==, 1); + tt_int_op(arg_is_qq || arg_is_a1, OP_EQ, 1);

if (arg_is_qq) return 1; @@ -1214,7 +1214,7 @@ NS(geoip_is_loaded)(sa_family_t family) { CALLED(geoip_is_loaded)++;

- tt_int_op(family, ==, AF_INET); + tt_int_op(family, OP_EQ, AF_INET);

done: return 0; @@ -1244,9 +1244,9 @@ NS(test_main)(void *arg)

r = routerset_add_unknown_ccs(setp, 0);

- tt_int_op(r, ==, 1); - tt_int_op(smartlist_contains_string(set->country_names, "a1"), ==, 1); - tt_int_op(smartlist_contains_string(set->list, "{a1}"), ==, 1); + tt_int_op(r, OP_EQ, 1); + tt_int_op(smartlist_contains_string(set->country_names, "a1"), OP_EQ, 1); + tt_int_op(smartlist_contains_string(set->list, "{a1}"), OP_EQ, 1);

done: if (set != NULL) @@ -1263,7 +1263,7 @@ NS(geoip_get_country)(const char *country) arg_is_qq = !strcmp(country, "??"); arg_is_a1 = !strcmp(country, "A1");

- tt_int_op(arg_is_qq || arg_is_a1, ==, 1); + tt_int_op(arg_is_qq || arg_is_a1, OP_EQ, 1);

if (arg_is_a1) return 1; @@ -1277,7 +1277,7 @@ NS(geoip_is_loaded)(sa_family_t family) { CALLED(geoip_is_loaded)++;

- tt_int_op(family, ==, AF_INET); + tt_int_op(family, OP_EQ, AF_INET);

done: return 0; @@ -1306,7 +1306,7 @@ NS(test_main)(void *arg)

r = routerset_contains_extendinfo(set, &ei);

- tt_int_op(r, ==, 4); + tt_int_op(r, OP_EQ, 4); done: routerset_free(set); } @@ -1334,7 +1334,7 @@ NS(test_main)(void *arg)

r = routerset_contains_router(set, &ri, country);

- tt_int_op(r, ==, 4); + tt_int_op(r, OP_EQ, 4); done: routerset_free(set); } @@ -1367,7 +1367,7 @@ NS(test_main)(void *arg)

r = routerset_contains_routerstatus(set, &rs, country);

- tt_int_op(r, ==, 4); + tt_int_op(r, OP_EQ, 4); done: routerset_free(set); } @@ -1393,7 +1393,7 @@ NS(test_main)(void *arg) NS(mock_node).rs = NULL;

r = routerset_contains_node(set, &NS(mock_node)); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0);

done: routerset_free(set); @@ -1427,7 +1427,7 @@ NS(test_main)(void *arg)

r = routerset_contains_node(set, &NS(mock_node));

- tt_int_op(r, ==, 4); + tt_int_op(r, OP_EQ, 4); done: routerset_free(set); } @@ -1458,7 +1458,7 @@ NS(test_main)(void *arg)

r = routerset_contains_node(set, &mock_node);

- tt_int_op(r, ==, 4); + tt_int_op(r, OP_EQ, 4); done: routerset_free(set); } @@ -1478,15 +1478,15 @@ NS(test_main)(void *arg) routerset_t *set = NULL; (void)arg;

- tt_int_op(smartlist_len(out), ==, 0); + tt_int_op(smartlist_len(out), OP_EQ, 0); routerset_get_all_nodes(out, NULL, NULL, 0);

- tt_int_op(smartlist_len(out), ==, 0); + tt_int_op(smartlist_len(out), OP_EQ, 0);

set = routerset_new(); smartlist_free(set->list); routerset_get_all_nodes(out, NULL, NULL, 0); - tt_int_op(smartlist_len(out), ==, 0); + tt_int_op(smartlist_len(out), OP_EQ, 0);

/* Just recreate list, so we can simply use routerset_free. */ set->list = smartlist_new(); @@ -1527,8 +1527,8 @@ NS(test_main)(void *arg) smartlist_free(out); routerset_free(set);

- tt_int_op(out_len, ==, 0); - tt_int_op(CALLED(node_get_by_nickname), ==, 1); + tt_int_op(out_len, OP_EQ, 0); + tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);

done: ; @@ -1538,8 +1538,8 @@ const node_t * NS(node_get_by_nickname)(const char *nickname, int warn_if_unused) { CALLED(node_get_by_nickname)++; - tt_str_op(nickname, ==, NS(mock_nickname)); - tt_int_op(warn_if_unused, ==, 1); + tt_str_op(nickname, OP_EQ, NS(mock_nickname)); + tt_int_op(warn_if_unused, OP_EQ, 1);

done: return NULL; @@ -1578,8 +1578,8 @@ NS(test_main)(void *arg) smartlist_free(out); routerset_free(set);

- tt_int_op(out_len, ==, 0); - tt_int_op(CALLED(node_get_by_nickname), ==, 1); + tt_int_op(out_len, OP_EQ, 0); + tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);

done: ; @@ -1589,8 +1589,8 @@ const node_t * NS(node_get_by_nickname)(const char *nickname, int warn_if_unused) { CALLED(node_get_by_nickname)++; - tt_str_op(nickname, ==, NS(mock_nickname)); - tt_int_op(warn_if_unused, ==, 1); + tt_str_op(nickname, OP_EQ, NS(mock_nickname)); + tt_int_op(warn_if_unused, OP_EQ, 1);

done: return &NS(mock_node); @@ -1629,9 +1629,9 @@ NS(test_main)(void *arg) smartlist_free(out); routerset_free(set);

- tt_int_op(out_len, ==, 1); - tt_ptr_op(ent, ==, &NS(mock_node)); - tt_int_op(CALLED(node_get_by_nickname), ==, 1); + tt_int_op(out_len, OP_EQ, 1); + tt_ptr_op(ent, OP_EQ, &NS(mock_node)); + tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);

done: ; @@ -1641,8 +1641,8 @@ const node_t * NS(node_get_by_nickname)(const char *nickname, int warn_if_unused) { CALLED(node_get_by_nickname)++; - tt_str_op(nickname, ==, NS(mock_nickname)); - tt_int_op(warn_if_unused, ==, 1); + tt_str_op(nickname, OP_EQ, NS(mock_nickname)); + tt_int_op(warn_if_unused, OP_EQ, 1);

done: return &NS(mock_node); @@ -1678,8 +1678,8 @@ NS(test_main)(void *arg) smartlist_free(out); smartlist_free(NS(mock_smartlist));

- tt_int_op(r, ==, 0); - tt_int_op(CALLED(nodelist_get_list), ==, 1); + tt_int_op(r, OP_EQ, 0); + tt_int_op(CALLED(nodelist_get_list), OP_EQ, 1);

done: ; @@ -1727,8 +1727,8 @@ NS(test_main)(void *arg) smartlist_free(out); smartlist_free(NS(mock_smartlist));

- tt_int_op(r, ==, 0); - tt_int_op(CALLED(nodelist_get_list), ==, 1); + tt_int_op(r, OP_EQ, 0); + tt_int_op(CALLED(nodelist_get_list), OP_EQ, 1);

done: ; @@ -1766,10 +1766,10 @@ NS(test_main)(void *arg) mock_node.ri = &ri; smartlist_add(list, (void *)&mock_node);

- tt_int_op(smartlist_len(list), !=, 0); + tt_int_op(smartlist_len(list), OP_NE, 0); routerset_subtract_nodes(list, set);

- tt_int_op(smartlist_len(list), ==, 0); + tt_int_op(smartlist_len(list), OP_EQ, 0); done: routerset_free(set); smartlist_free(list); @@ -1796,10 +1796,10 @@ NS(test_main)(void *arg) mock_node.ri = &ri; smartlist_add(list, (void *)&mock_node);

- tt_int_op(smartlist_len(list), !=, 0); + tt_int_op(smartlist_len(list), OP_NE, 0); routerset_subtract_nodes(list, set);

- tt_int_op(smartlist_len(list), !=, 0); + tt_int_op(smartlist_len(list), OP_NE, 0); done: routerset_free(set); smartlist_free(list); @@ -1821,19 +1821,19 @@ NS(test_main)(void *arg)

set = NULL; s = routerset_to_string(set); - tt_str_op(s, ==, ""); + tt_str_op(s, OP_EQ, ""); tor_free(s);

set = routerset_new(); s = routerset_to_string(set); - tt_str_op(s, ==, ""); + tt_str_op(s, OP_EQ, ""); tor_free(s); routerset_free(set); set = NULL;

set = routerset_new(); smartlist_add(set->list, tor_strndup("a", 1)); s = routerset_to_string(set); - tt_str_op(s, ==, "a"); + tt_str_op(s, OP_EQ, "a"); tor_free(s); routerset_free(set); set = NULL;

@@ -1841,7 +1841,7 @@ NS(test_main)(void *arg) smartlist_add(set->list, tor_strndup("a", 1)); smartlist_add(set->list, tor_strndup("b", 1)); s = routerset_to_string(set); - tt_str_op(s, ==, "a,b"); + tt_str_op(s, OP_EQ, "a,b"); tor_free(s); routerset_free(set); set = NULL;

@@ -1868,7 +1868,7 @@ NS(test_main)(void *arg) routerset_free(a); routerset_free(b);

- tt_int_op(r, ==, 1); + tt_int_op(r, OP_EQ, 1);

done: ; @@ -1893,7 +1893,7 @@ NS(test_main)(void *arg) routerset_free(a); routerset_free(b);

- tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); done: ; } @@ -1920,7 +1920,7 @@ NS(test_main)(void *arg) routerset_free(a); routerset_free(b);

- tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); done: ; } @@ -1946,7 +1946,7 @@ NS(test_main)(void *arg) routerset_free(a); routerset_free(b);

- tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); done: ; } @@ -1972,7 +1972,7 @@ NS(test_main)(void *arg) routerset_free(a); routerset_free(b);

- tt_int_op(r, ==, 1); + tt_int_op(r, OP_EQ, 1); done: ; } @@ -1995,7 +1995,7 @@ NS(test_main)(void *arg)

routerset_free(NULL);

- tt_int_op(CALLED(smartlist_free), ==, 0); + tt_int_op(CALLED(smartlist_free), OP_EQ, 0);

done: ; @@ -2031,9 +2031,9 @@ NS(test_main)(void *arg)

routerset_free(routerset);

- tt_int_op(CALLED(smartlist_free), !=, 0); - tt_int_op(CALLED(strmap_free), !=, 0); - tt_int_op(CALLED(digestmap_free), !=, 0); + tt_int_op(CALLED(smartlist_free), OP_NE, 0); + tt_int_op(CALLED(strmap_free), OP_NE, 0); + tt_int_op(CALLED(digestmap_free), OP_NE, 0);

done: ; diff --git a/src/test/test_socks.c b/src/test/test_socks.c index 29faa69..98c5be0 100644 --- a/src/test/test_socks.c +++ b/src/test/test_socks.c @@ -63,8 +63,8 @@ test_socks_4_unsupported_commands(void *ptr) ADD_DATA(buf, "\x04\x02\x11\x11\x02\x02\x02\x02\x00"); tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, get_options()->SafeSocks) == -1); - tt_int_op(4,==, socks->socks_version); - tt_int_op(0,==, socks->replylen); /* XXX: shouldn't tor reply? */ + tt_int_op(4,OP_EQ, socks->socks_version); + tt_int_op(0,OP_EQ, socks->replylen); /* XXX: shouldn't tor reply? */

done: ; @@ -76,49 +76,49 @@ test_socks_4_supported_commands(void *ptr) { SOCKS_TEST_INIT();

- tt_int_op(0,==, buf_datalen(buf)); + tt_int_op(0,OP_EQ, buf_datalen(buf));

/* SOCKS 4 Send CONNECT [01] to IP address 2.2.2.2:4370 */ ADD_DATA(buf, "\x04\x01\x11\x12\x02\x02\x02\x03\x00"); tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, get_options()->SafeSocks) == 1); - tt_int_op(4,==, socks->socks_version); - tt_int_op(0,==, socks->replylen); /* XXX: shouldn't tor reply? */ - tt_int_op(SOCKS_COMMAND_CONNECT,==, socks->command); - tt_str_op("2.2.2.3",==, socks->address); - tt_int_op(4370,==, socks->port); + tt_int_op(4,OP_EQ, socks->socks_version); + tt_int_op(0,OP_EQ, socks->replylen); /* XXX: shouldn't tor reply? */ + tt_int_op(SOCKS_COMMAND_CONNECT,OP_EQ, socks->command); + tt_str_op("2.2.2.3",OP_EQ, socks->address); + tt_int_op(4370,OP_EQ, socks->port); tt_assert(socks->got_auth == 0); tt_assert(! socks->username);

- tt_int_op(0,==, buf_datalen(buf)); + tt_int_op(0,OP_EQ, buf_datalen(buf)); socks_request_clear(socks);

/* SOCKS 4 Send CONNECT [01] to IP address 2.2.2.2:4369 with userid*/ ADD_DATA(buf, "\x04\x01\x11\x12\x02\x02\x02\x04me\x00"); tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, get_options()->SafeSocks) == 1); - tt_int_op(4,==, socks->socks_version); - tt_int_op(0,==, socks->replylen); /* XXX: shouldn't tor reply? */ - tt_int_op(SOCKS_COMMAND_CONNECT,==, socks->command); - tt_str_op("2.2.2.4",==, socks->address); - tt_int_op(4370,==, socks->port); + tt_int_op(4,OP_EQ, socks->socks_version); + tt_int_op(0,OP_EQ, socks->replylen); /* XXX: shouldn't tor reply? */ + tt_int_op(SOCKS_COMMAND_CONNECT,OP_EQ, socks->command); + tt_str_op("2.2.2.4",OP_EQ, socks->address); + tt_int_op(4370,OP_EQ, socks->port); tt_assert(socks->got_auth == 1); tt_assert(socks->username); - tt_int_op(2,==, socks->usernamelen); - tt_mem_op("me",==, socks->username, 2); + tt_int_op(2,OP_EQ, socks->usernamelen); + tt_mem_op("me",OP_EQ, socks->username, 2);

- tt_int_op(0,==, buf_datalen(buf)); + tt_int_op(0,OP_EQ, buf_datalen(buf)); socks_request_clear(socks);

/* SOCKS 4a Send RESOLVE [F0] request for torproject.org */ ADD_DATA(buf, "\x04\xF0\x01\x01\x00\x00\x00\x02me\x00torproject.org\x00"); tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, get_options()->SafeSocks) == 1); - tt_int_op(4,==, socks->socks_version); - tt_int_op(0,==, socks->replylen); /* XXX: shouldn't tor reply? */ - tt_str_op("torproject.org",==, socks->address); + tt_int_op(4,OP_EQ, socks->socks_version); + tt_int_op(0,OP_EQ, socks->replylen); /* XXX: shouldn't tor reply? */ + tt_str_op("torproject.org",OP_EQ, socks->address);

- tt_int_op(0,==, buf_datalen(buf)); + tt_int_op(0,OP_EQ, buf_datalen(buf));

done: ; @@ -134,21 +134,21 @@ test_socks_5_unsupported_commands(void *ptr) ADD_DATA(buf, "\x05\x02\x00\x01");

tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, - get_options()->SafeSocks),==, 0); - tt_int_op(0,==, buf_datalen(buf)); - tt_int_op(5,==, socks->socks_version); - tt_int_op(2,==, socks->replylen); - tt_int_op(5,==, socks->reply[0]); - tt_int_op(0,==, socks->reply[1]); + get_options()->SafeSocks),OP_EQ, 0); + tt_int_op(0,OP_EQ, buf_datalen(buf)); + tt_int_op(5,OP_EQ, socks->socks_version); + tt_int_op(2,OP_EQ, socks->replylen); + tt_int_op(5,OP_EQ, socks->reply[0]); + tt_int_op(0,OP_EQ, socks->reply[1]); ADD_DATA(buf, "\x05\x02\x00\x01\x02\x02\x02\x01\x01\x01"); tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, - get_options()->SafeSocks),==, -1); + get_options()->SafeSocks),OP_EQ, -1);

- tt_int_op(5,==,socks->socks_version); - tt_int_op(10,==,socks->replylen); - tt_int_op(5,==,socks->reply[0]); - tt_int_op(SOCKS5_COMMAND_NOT_SUPPORTED,==,socks->reply[1]); - tt_int_op(1,==,socks->reply[3]); + tt_int_op(5,OP_EQ,socks->socks_version); + tt_int_op(10,OP_EQ,socks->replylen); + tt_int_op(5,OP_EQ,socks->reply[0]); + tt_int_op(SOCKS5_COMMAND_NOT_SUPPORTED,OP_EQ,socks->reply[1]); + tt_int_op(1,OP_EQ,socks->reply[3]);

buf_clear(buf); socks_request_clear(socks); @@ -156,20 +156,20 @@ test_socks_5_unsupported_commands(void *ptr) /* SOCKS 5 Send unsupported UDP_ASSOCIATE [03] command */ ADD_DATA(buf, "\x05\x02\x00\x01"); tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, - get_options()->SafeSocks),==, 0); - tt_int_op(5,==, socks->socks_version); - tt_int_op(2,==, socks->replylen); - tt_int_op(5,==, socks->reply[0]); - tt_int_op(0,==, socks->reply[1]); + get_options()->SafeSocks),OP_EQ, 0); + tt_int_op(5,OP_EQ, socks->socks_version); + tt_int_op(2,OP_EQ, socks->replylen); + tt_int_op(5,OP_EQ, socks->reply[0]); + tt_int_op(0,OP_EQ, socks->reply[1]); ADD_DATA(buf, "\x05\x03\x00\x01\x02\x02\x02\x01\x01\x01"); tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, - get_options()->SafeSocks),==, -1); + get_options()->SafeSocks),OP_EQ, -1);

- tt_int_op(5,==,socks->socks_version); - tt_int_op(10,==,socks->replylen); - tt_int_op(5,==,socks->reply[0]); - tt_int_op(SOCKS5_COMMAND_NOT_SUPPORTED,==,socks->reply[1]); - tt_int_op(1,==,socks->reply[3]); + tt_int_op(5,OP_EQ,socks->socks_version); + tt_int_op(10,OP_EQ,socks->replylen); + tt_int_op(5,OP_EQ,socks->reply[0]); + tt_int_op(SOCKS5_COMMAND_NOT_SUPPORTED,OP_EQ,socks->reply[1]); + tt_int_op(1,OP_EQ,socks->reply[3]);

done: ; @@ -184,35 +184,35 @@ test_socks_5_supported_commands(void *ptr) /* SOCKS 5 Send CONNECT [01] to IP address 2.2.2.2:4369 */ ADD_DATA(buf, "\x05\x01\x00"); tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, - get_options()->SafeSocks),==, 0); - tt_int_op(5,==, socks->socks_version); - tt_int_op(2,==, socks->replylen); - tt_int_op(5,==, socks->reply[0]); - tt_int_op(0,==, socks->reply[1]); + get_options()->SafeSocks),OP_EQ, 0); + tt_int_op(5,OP_EQ, socks->socks_version); + tt_int_op(2,OP_EQ, socks->replylen); + tt_int_op(5,OP_EQ, socks->reply[0]); + tt_int_op(0,OP_EQ, socks->reply[1]);

ADD_DATA(buf, "\x05\x01\x00\x01\x02\x02\x02\x02\x11\x11"); tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, - get_options()->SafeSocks),==, 1); - tt_str_op("2.2.2.2",==, socks->address); - tt_int_op(4369,==, socks->port); + get_options()->SafeSocks),OP_EQ, 1); + tt_str_op("2.2.2.2",OP_EQ, socks->address); + tt_int_op(4369,OP_EQ, socks->port);

- tt_int_op(0,==, buf_datalen(buf)); + tt_int_op(0,OP_EQ, buf_datalen(buf)); socks_request_clear(socks);

/* SOCKS 5 Send CONNECT [01] to FQDN torproject.org:4369 */ ADD_DATA(buf, "\x05\x01\x00"); ADD_DATA(buf, "\x05\x01\x00\x03\x0Etorproject.org\x11\x11"); tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, - get_options()->SafeSocks),==, 1); + get_options()->SafeSocks),OP_EQ, 1);

- tt_int_op(5,==, socks->socks_version); - tt_int_op(2,==, socks->replylen); - tt_int_op(5,==, socks->reply[0]); - tt_int_op(0,==, socks->reply[1]); - tt_str_op("torproject.org",==, socks->address); - tt_int_op(4369,==, socks->port); + tt_int_op(5,OP_EQ, socks->socks_version); + tt_int_op(2,OP_EQ, socks->replylen); + tt_int_op(5,OP_EQ, socks->reply[0]); + tt_int_op(0,OP_EQ, socks->reply[1]); + tt_str_op("torproject.org",OP_EQ, socks->address); + tt_int_op(4369,OP_EQ, socks->port);

- tt_int_op(0,==, buf_datalen(buf)); + tt_int_op(0,OP_EQ, buf_datalen(buf)); socks_request_clear(socks);

/* SOCKS 5 Send RESOLVE [F0] request for torproject.org:4369 */ @@ -220,13 +220,13 @@ test_socks_5_supported_commands(void *ptr) ADD_DATA(buf, "\x05\xF0\x00\x03\x0Etorproject.org\x01\x02"); tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, get_options()->SafeSocks) == 1); - tt_int_op(5,==, socks->socks_version); - tt_int_op(2,==, socks->replylen); - tt_int_op(5,==, socks->reply[0]); - tt_int_op(0,==, socks->reply[1]); - tt_str_op("torproject.org",==, socks->address); + tt_int_op(5,OP_EQ, socks->socks_version); + tt_int_op(2,OP_EQ, socks->replylen); + tt_int_op(5,OP_EQ, socks->reply[0]); + tt_int_op(0,OP_EQ, socks->reply[1]); + tt_str_op("torproject.org",OP_EQ, socks->address);

- tt_int_op(0,==, buf_datalen(buf)); + tt_int_op(0,OP_EQ, buf_datalen(buf)); socks_request_clear(socks);

/* SOCKS 5 Should reject RESOLVE [F0] request for IPv4 address @@ -239,11 +239,11 @@ test_socks_5_supported_commands(void *ptr) tt_assert(fetch_from_buf_socks(buf,socks,get_options()->TestSocks,1) == -1);

- tt_int_op(5,==,socks->socks_version); - tt_int_op(10,==,socks->replylen); - tt_int_op(5,==,socks->reply[0]); - tt_int_op(SOCKS5_NOT_ALLOWED,==,socks->reply[1]); - tt_int_op(1,==,socks->reply[3]); + tt_int_op(5,OP_EQ,socks->socks_version); + tt_int_op(10,OP_EQ,socks->replylen); + tt_int_op(5,OP_EQ,socks->reply[0]); + tt_int_op(SOCKS5_NOT_ALLOWED,OP_EQ,socks->reply[1]); + tt_int_op(1,OP_EQ,socks->reply[3]);

socks_request_clear(socks);

@@ -257,11 +257,11 @@ test_socks_5_supported_commands(void *ptr) tt_assert(fetch_from_buf_socks(buf,socks,get_options()->TestSocks,1) == -1);

- tt_int_op(5,==,socks->socks_version); - tt_int_op(10,==,socks->replylen); - tt_int_op(5,==,socks->reply[0]); - tt_int_op(SOCKS5_NOT_ALLOWED,==,socks->reply[1]); - tt_int_op(1,==,socks->reply[3]); + tt_int_op(5,OP_EQ,socks->socks_version); + tt_int_op(10,OP_EQ,socks->replylen); + tt_int_op(5,OP_EQ,socks->reply[0]); + tt_int_op(SOCKS5_NOT_ALLOWED,OP_EQ,socks->reply[1]); + tt_int_op(1,OP_EQ,socks->reply[3]);

socks_request_clear(socks);

@@ -270,13 +270,13 @@ test_socks_5_supported_commands(void *ptr) ADD_DATA(buf, "\x05\xF1\x00\x01\x02\x02\x02\x05\x01\x03"); tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, get_options()->SafeSocks) == 1); - tt_int_op(5,==, socks->socks_version); - tt_int_op(2,==, socks->replylen); - tt_int_op(5,==, socks->reply[0]); - tt_int_op(0,==, socks->reply[1]); - tt_str_op("2.2.2.5",==, socks->address); + tt_int_op(5,OP_EQ, socks->socks_version); + tt_int_op(2,OP_EQ, socks->replylen); + tt_int_op(5,OP_EQ, socks->reply[0]); + tt_int_op(0,OP_EQ, socks->reply[1]); + tt_str_op("2.2.2.5",OP_EQ, socks->address);

- tt_int_op(0,==, buf_datalen(buf)); + tt_int_op(0,OP_EQ, buf_datalen(buf));

done: ; @@ -293,27 +293,27 @@ test_socks_5_no_authenticate(void *ptr) tt_assert(!fetch_from_buf_socks(buf, socks, get_options()->TestSocks, get_options()->SafeSocks)); - tt_int_op(2,==, socks->replylen); - tt_int_op(5,==, socks->reply[0]); - tt_int_op(SOCKS_NO_AUTH,==, socks->reply[1]); + tt_int_op(2,OP_EQ, socks->replylen); + tt_int_op(5,OP_EQ, socks->reply[0]); + tt_int_op(SOCKS_NO_AUTH,OP_EQ, socks->reply[1]);

- tt_int_op(0,==, buf_datalen(buf)); + tt_int_op(0,OP_EQ, buf_datalen(buf));

/*SOCKS 5 Send username/password anyway - pretend to be broken */ ADD_DATA(buf,"\x01\x02\x01\x01\x02\x01\x01"); tt_assert(!fetch_from_buf_socks(buf, socks, get_options()->TestSocks, get_options()->SafeSocks)); - tt_int_op(5,==, socks->socks_version); - tt_int_op(2,==, socks->replylen); - tt_int_op(1,==, socks->reply[0]); - tt_int_op(0,==, socks->reply[1]); + tt_int_op(5,OP_EQ, socks->socks_version); + tt_int_op(2,OP_EQ, socks->replylen); + tt_int_op(1,OP_EQ, socks->reply[0]); + tt_int_op(0,OP_EQ, socks->reply[1]);

- tt_int_op(2,==, socks->usernamelen); - tt_int_op(2,==, socks->passwordlen); + tt_int_op(2,OP_EQ, socks->usernamelen); + tt_int_op(2,OP_EQ, socks->passwordlen);

- tt_mem_op("\x01\x01",==, socks->username, 2); - tt_mem_op("\x01\x01",==, socks->password, 2); + tt_mem_op("\x01\x01",OP_EQ, socks->username, 2); + tt_mem_op("\x01\x01",OP_EQ, socks->password, 2);

done: ; @@ -331,28 +331,28 @@ test_socks_5_authenticate(void *ptr) tt_assert(!fetch_from_buf_socks(buf, socks, get_options()->TestSocks, get_options()->SafeSocks)); - tt_int_op(2,==, socks->replylen); - tt_int_op(5,==, socks->reply[0]); - tt_int_op(SOCKS_USER_PASS,==, socks->reply[1]); - tt_int_op(5,==, socks->socks_version); + tt_int_op(2,OP_EQ, socks->replylen); + tt_int_op(5,OP_EQ, socks->reply[0]); + tt_int_op(SOCKS_USER_PASS,OP_EQ, socks->reply[1]); + tt_int_op(5,OP_EQ, socks->socks_version);

- tt_int_op(0,==, buf_datalen(buf)); + tt_int_op(0,OP_EQ, buf_datalen(buf));

/* SOCKS 5 Send username/password */ ADD_DATA(buf, "\x01\x02me\x08mypasswd"); tt_assert(!fetch_from_buf_socks(buf, socks, get_options()->TestSocks, get_options()->SafeSocks)); - tt_int_op(5,==, socks->socks_version); - tt_int_op(2,==, socks->replylen); - tt_int_op(1,==, socks->reply[0]); - tt_int_op(0,==, socks->reply[1]); + tt_int_op(5,OP_EQ, socks->socks_version); + tt_int_op(2,OP_EQ, socks->replylen); + tt_int_op(1,OP_EQ, socks->reply[0]); + tt_int_op(0,OP_EQ, socks->reply[1]);

- tt_int_op(2,==, socks->usernamelen); - tt_int_op(8,==, socks->passwordlen); + tt_int_op(2,OP_EQ, socks->usernamelen); + tt_int_op(8,OP_EQ, socks->passwordlen);

- tt_mem_op("me",==, socks->username, 2); - tt_mem_op("mypasswd",==, socks->password, 8); + tt_mem_op("me",OP_EQ, socks->username, 2); + tt_mem_op("mypasswd",OP_EQ, socks->password, 8);

done: ; @@ -370,12 +370,12 @@ test_socks_5_authenticate_with_data(void *ptr) tt_assert(!fetch_from_buf_socks(buf, socks, get_options()->TestSocks, get_options()->SafeSocks)); - tt_int_op(2,==, socks->replylen); - tt_int_op(5,==, socks->reply[0]); - tt_int_op(SOCKS_USER_PASS,==, socks->reply[1]); - tt_int_op(5,==, socks->socks_version); + tt_int_op(2,OP_EQ, socks->replylen); + tt_int_op(5,OP_EQ, socks->reply[0]); + tt_int_op(SOCKS_USER_PASS,OP_EQ, socks->reply[1]); + tt_int_op(5,OP_EQ, socks->socks_version);

- tt_int_op(0,==, buf_datalen(buf)); + tt_int_op(0,OP_EQ, buf_datalen(buf));

/* SOCKS 5 Send username/password */ /* SOCKS 5 Send CONNECT [01] to IP address 2.2.2.2:4369 */ @@ -383,18 +383,18 @@ test_socks_5_authenticate_with_data(void *ptr) tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, get_options()->SafeSocks) == 1); - tt_int_op(5,==, socks->socks_version); - tt_int_op(2,==, socks->replylen); - tt_int_op(1,==, socks->reply[0]); - tt_int_op(0,==, socks->reply[1]); + tt_int_op(5,OP_EQ, socks->socks_version); + tt_int_op(2,OP_EQ, socks->replylen); + tt_int_op(1,OP_EQ, socks->reply[0]); + tt_int_op(0,OP_EQ, socks->reply[1]);

- tt_str_op("2.2.2.2",==, socks->address); - tt_int_op(4369,==, socks->port); + tt_str_op("2.2.2.2",OP_EQ, socks->address); + tt_int_op(4369,OP_EQ, socks->port);

- tt_int_op(2,==, socks->usernamelen); - tt_int_op(3,==, socks->passwordlen); - tt_mem_op("me",==, socks->username, 2); - tt_mem_op("you",==, socks->password, 3); + tt_int_op(2,OP_EQ, socks->usernamelen); + tt_int_op(3,OP_EQ, socks->passwordlen); + tt_mem_op("me",OP_EQ, socks->username, 2); + tt_mem_op("you",OP_EQ, socks->password, 3);

done: ; @@ -411,10 +411,10 @@ test_socks_5_auth_before_negotiation(void *ptr) tt_assert(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, get_options()->SafeSocks) == -1); - tt_int_op(0,==, socks->socks_version); - tt_int_op(0,==, socks->replylen); - tt_int_op(0,==, socks->reply[0]); - tt_int_op(0,==, socks->reply[1]); + tt_int_op(0,OP_EQ, socks->socks_version); + tt_int_op(0,OP_EQ, socks->replylen); + tt_int_op(0,OP_EQ, socks->reply[0]); + tt_int_op(0,OP_EQ, socks->reply[1]);

done: ; @@ -432,14 +432,14 @@ test_socks_5_malformed_commands(void *ptr) */ ADD_DATA(buf, "\x05\x01\x00"); ADD_DATA(buf, "\x05\x01\x00\x01\x02\x02\x02\x02\x11\x11"); - tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, 1),==, + tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, 1),OP_EQ, -1);

- tt_int_op(5,==,socks->socks_version); - tt_int_op(10,==,socks->replylen); - tt_int_op(5,==,socks->reply[0]); - tt_int_op(SOCKS5_NOT_ALLOWED,==,socks->reply[1]); - tt_int_op(1,==,socks->reply[3]); + tt_int_op(5,OP_EQ,socks->socks_version); + tt_int_op(10,OP_EQ,socks->replylen); + tt_int_op(5,OP_EQ,socks->reply[0]); + tt_int_op(SOCKS5_NOT_ALLOWED,OP_EQ,socks->reply[1]); + tt_int_op(1,OP_EQ,socks->reply[3]);

buf_clear(buf); socks_request_clear(socks); @@ -448,13 +448,13 @@ test_socks_5_malformed_commands(void *ptr) ADD_DATA(buf, "\x05\x01\x00"); ADD_DATA(buf, "\x05\xF1\x00\x03\x0Etorproject.org\x11\x11"); tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, - get_options()->SafeSocks),==, -1); + get_options()->SafeSocks),OP_EQ, -1);

- tt_int_op(5,==,socks->socks_version); - tt_int_op(10,==,socks->replylen); - tt_int_op(5,==,socks->reply[0]); - tt_int_op(SOCKS5_ADDRESS_TYPE_NOT_SUPPORTED,==,socks->reply[1]); - tt_int_op(1,==,socks->reply[3]); + tt_int_op(5,OP_EQ,socks->socks_version); + tt_int_op(10,OP_EQ,socks->replylen); + tt_int_op(5,OP_EQ,socks->reply[0]); + tt_int_op(SOCKS5_ADDRESS_TYPE_NOT_SUPPORTED,OP_EQ,socks->reply[1]); + tt_int_op(1,OP_EQ,socks->reply[3]);

buf_clear(buf); socks_request_clear(socks); @@ -465,13 +465,13 @@ test_socks_5_malformed_commands(void *ptr) ADD_DATA(buf, "\x05\x01\x00"); ADD_DATA(buf, "\x05\x01\x00\x03\x09""""".com\x11\x11"); tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, - get_options()->SafeSocks),==, -1); + get_options()->SafeSocks),OP_EQ, -1);

- tt_int_op(5,==,socks->socks_version); - tt_int_op(10,==,socks->replylen); - tt_int_op(5,==,socks->reply[0]); - tt_int_op(SOCKS5_GENERAL_ERROR,==,socks->reply[1]); - tt_int_op(1,==,socks->reply[3]); + tt_int_op(5,OP_EQ,socks->socks_version); + tt_int_op(10,OP_EQ,socks->replylen); + tt_int_op(5,OP_EQ,socks->reply[0]); + tt_int_op(SOCKS5_GENERAL_ERROR,OP_EQ,socks->reply[1]); + tt_int_op(1,OP_EQ,socks->reply[3]);

buf_clear(buf); socks_request_clear(socks); @@ -480,13 +480,13 @@ test_socks_5_malformed_commands(void *ptr) ADD_DATA(buf, "\x05\x01\x00"); ADD_DATA(buf, "\x05\x01\x00\x23\x02\x02\x02\x02\x11\x11"); tt_int_op(fetch_from_buf_socks(buf, socks, get_options()->TestSocks, - get_options()->SafeSocks),==, -1); + get_options()->SafeSocks),OP_EQ, -1);

- tt_int_op(5,==,socks->socks_version); - tt_int_op(10,==,socks->replylen); - tt_int_op(5,==,socks->reply[0]); - tt_int_op(SOCKS5_ADDRESS_TYPE_NOT_SUPPORTED,==,socks->reply[1]); - tt_int_op(1,==,socks->reply[3]); + tt_int_op(5,OP_EQ,socks->socks_version); + tt_int_op(10,OP_EQ,socks->replylen); + tt_int_op(5,OP_EQ,socks->reply[0]); + tt_int_op(SOCKS5_ADDRESS_TYPE_NOT_SUPPORTED,OP_EQ,socks->reply[1]); + tt_int_op(1,OP_EQ,socks->reply[3]);

done: ; diff --git a/src/test/test_status.c b/src/test/test_status.c index 8bc0152..dd825f2 100644 --- a/src/test/test_status.c +++ b/src/test/test_status.c @@ -86,62 +86,62 @@ NS(test_main)(void *arg)

expected = "0:00 hours"; actual = secs_to_uptime(0); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "0:00 hours"; actual = secs_to_uptime(1); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "0:01 hours"; actual = secs_to_uptime(60); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "0:59 hours"; actual = secs_to_uptime(60 * 59); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "1:00 hours"; actual = secs_to_uptime(60 * 60); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "23:59 hours"; actual = secs_to_uptime(60 * 60 * 23 + 60 * 59); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "1 day 0:00 hours"; actual = secs_to_uptime(60 * 60 * 23 + 60 * 60); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "1 day 0:00 hours"; actual = secs_to_uptime(86400 + 1); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "1 day 0:01 hours"; actual = secs_to_uptime(86400 + 60); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "10 days 0:00 hours"; actual = secs_to_uptime(86400 * 10); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "10 days 0:00 hours"; actual = secs_to_uptime(864000 + 1); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "10 days 0:01 hours"; actual = secs_to_uptime(864000 + 60); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

done: @@ -167,62 +167,62 @@ NS(test_main)(void *arg)

expected = "0 kB"; actual = bytes_to_usage(0); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "0 kB"; actual = bytes_to_usage(1); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "1 kB"; actual = bytes_to_usage(1024); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "1023 kB"; actual = bytes_to_usage((1 << 20) - 1); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "1.00 MB"; actual = bytes_to_usage((1 << 20)); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "1.00 MB"; actual = bytes_to_usage((1 << 20) + 5242); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "1.01 MB"; actual = bytes_to_usage((1 << 20) + 5243); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "1024.00 MB"; actual = bytes_to_usage((1 << 30) - 1); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "1.00 GB"; actual = bytes_to_usage((1 << 30)); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "1.00 GB"; actual = bytes_to_usage((1 << 30) + 5368709); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "1.01 GB"; actual = bytes_to_usage((1 << 30) + 5368710); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

expected = "10.00 GB"; actual = bytes_to_usage((U64_LITERAL(1) << 30) * 10L); - tt_str_op(actual, ==, expected); + tt_str_op(actual, OP_EQ, expected); tor_free(actual);

done: @@ -259,7 +259,7 @@ NS(test_main)(void *arg) expected = -1; actual = log_heartbeat(0);

- tt_int_op(actual, ==, expected); + tt_int_op(actual, OP_EQ, expected);

done: NS_UNMOCK(tls_get_write_overhead_ratio); @@ -347,8 +347,8 @@ NS(test_main)(void *arg) expected = 0; actual = log_heartbeat(0);

- tt_int_op(actual, ==, expected); - tt_int_op(CALLED(logv), ==, 3); + tt_int_op(actual, OP_EQ, expected); + tt_int_op(CALLED(logv), OP_EQ, 3);

done: NS_UNMOCK(tls_get_write_overhead_ratio); @@ -411,39 +411,39 @@ NS(logv)(int severity, log_domain_mask_t domain, switch (CALLED(logv)) { case 0: - tt_int_op(severity, ==, LOG_NOTICE); - tt_int_op(domain, ==, LD_HEARTBEAT); - tt_ptr_op(strstr(funcname, "log_heartbeat"), !=, NULL); - tt_ptr_op(suffix, ==, NULL); - tt_str_op(format, ==, + tt_int_op(severity, OP_EQ, LOG_NOTICE); + tt_int_op(domain, OP_EQ, LD_HEARTBEAT); + tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL); + tt_ptr_op(suffix, OP_EQ, NULL); + tt_str_op(format, OP_EQ, "Heartbeat: It seems like we are not in the cached consensus."); break; case 1: - tt_int_op(severity, ==, LOG_NOTICE); - tt_int_op(domain, ==, LD_HEARTBEAT); - tt_ptr_op(strstr(funcname, "log_heartbeat"), !=, NULL); - tt_ptr_op(suffix, ==, NULL); - tt_str_op(format, ==, + tt_int_op(severity, OP_EQ, LOG_NOTICE); + tt_int_op(domain, OP_EQ, LD_HEARTBEAT); + tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL); + tt_ptr_op(suffix, OP_EQ, NULL); + tt_str_op(format, OP_EQ, "Heartbeat: Tor's uptime is %s, with %d circuits open. " "I've sent %s and received %s.%s"); - tt_str_op(va_arg(ap, char *), ==, "0:00 hours"); /* uptime */ - tt_int_op(va_arg(ap, int), ==, 0); /* count_circuits() */ - tt_str_op(va_arg(ap, char *), ==, "0 kB"); /* bw_sent */ - tt_str_op(va_arg(ap, char *), ==, "0 kB"); /* bw_rcvd */ - tt_str_op(va_arg(ap, char *), ==, ""); /* hibernating */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0:00 hours"); /* uptime */ + tt_int_op(va_arg(ap, int), OP_EQ, 0); /* count_circuits() */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB"); /* bw_sent */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB"); /* bw_rcvd */ + tt_str_op(va_arg(ap, char *), OP_EQ, ""); /* hibernating */ break; case 2: - tt_int_op(severity, ==, LOG_NOTICE); - tt_int_op(domain, ==, LD_HEARTBEAT); + tt_int_op(severity, OP_EQ, LOG_NOTICE); + tt_int_op(domain, OP_EQ, LD_HEARTBEAT); tt_ptr_op( - strstr(funcname, "rep_hist_log_circuit_handshake_stats"), !=, NULL); - tt_ptr_op(suffix, ==, NULL); - tt_str_op(format, ==, + strstr(funcname, "rep_hist_log_circuit_handshake_stats"), OP_NE, NULL); + tt_ptr_op(suffix, OP_EQ, NULL); + tt_str_op(format, OP_EQ, "Circuit handshake stats since last time: %d/%d TAP, %d/%d NTor."); - tt_int_op(va_arg(ap, int), ==, 1); /* handshakes assigned (TAP) */ - tt_int_op(va_arg(ap, int), ==, 1); /* handshakes requested (TAP) */ - tt_int_op(va_arg(ap, int), ==, 1); /* handshakes assigned (NTOR) */ - tt_int_op(va_arg(ap, int), ==, 1); /* handshakes requested (NTOR) */ + tt_int_op(va_arg(ap, int), OP_EQ, 1); /* handshakes assigned (TAP) */ + tt_int_op(va_arg(ap, int), OP_EQ, 1); /* handshakes requested (TAP) */ + tt_int_op(va_arg(ap, int), OP_EQ, 1); /* handshakes assigned (NTOR) */ + tt_int_op(va_arg(ap, int), OP_EQ, 1); /* handshakes requested (NTOR) */ break; default: tt_abort_msg("unexpected call to logv()"); // TODO: prettyprint args @@ -502,7 +502,7 @@ NS(test_main)(void *arg) expected = 0; actual = log_heartbeat(0);

- tt_int_op(actual, ==, expected); + tt_int_op(actual, OP_EQ, expected);

done: NS_UNMOCK(tls_get_write_overhead_ratio); @@ -564,18 +564,18 @@ static void NS(logv)(int severity, log_domain_mask_t domain, const char *funcname, const char *suffix, const char *format, va_list ap) { - tt_int_op(severity, ==, LOG_NOTICE); - tt_int_op(domain, ==, LD_HEARTBEAT); - tt_ptr_op(strstr(funcname, "log_heartbeat"), !=, NULL); - tt_ptr_op(suffix, ==, NULL); - tt_str_op(format, ==, + tt_int_op(severity, OP_EQ, LOG_NOTICE); + tt_int_op(domain, OP_EQ, LD_HEARTBEAT); + tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL); + tt_ptr_op(suffix, OP_EQ, NULL); + tt_str_op(format, OP_EQ, "Heartbeat: Tor's uptime is %s, with %d circuits open. " "I've sent %s and received %s.%s"); - tt_str_op(va_arg(ap, char *), ==, "0:00 hours"); /* uptime */ - tt_int_op(va_arg(ap, int), ==, 0); /* count_circuits() */ - tt_str_op(va_arg(ap, char *), ==, "0 kB"); /* bw_sent */ - tt_str_op(va_arg(ap, char *), ==, "0 kB"); /* bw_rcvd */ - tt_str_op(va_arg(ap, char *), ==, " We are currently hibernating."); + tt_str_op(va_arg(ap, char *), OP_EQ, "0:00 hours"); /* uptime */ + tt_int_op(va_arg(ap, int), OP_EQ, 0); /* count_circuits() */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB"); /* bw_sent */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB"); /* bw_rcvd */ + tt_str_op(va_arg(ap, char *), OP_EQ, " We are currently hibernating.");

done: ; @@ -638,8 +638,8 @@ NS(test_main)(void *arg) expected = 0; actual = log_heartbeat(0);

- tt_int_op(actual, ==, expected); - tt_int_op(CALLED(logv), ==, 2); + tt_int_op(actual, OP_EQ, expected); + tt_int_op(CALLED(logv), OP_EQ, 2);

done: NS_UNMOCK(tls_get_write_overhead_ratio); @@ -711,34 +711,34 @@ NS(logv)(int severity, log_domain_mask_t domain, switch (CALLED(logv)) { case 0: - tt_int_op(severity, ==, LOG_NOTICE); - tt_int_op(domain, ==, LD_HEARTBEAT); - tt_ptr_op(strstr(funcname, "log_heartbeat"), !=, NULL); - tt_ptr_op(suffix, ==, NULL); - tt_str_op(format, ==, + tt_int_op(severity, OP_EQ, LOG_NOTICE); + tt_int_op(domain, OP_EQ, LD_HEARTBEAT); + tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL); + tt_ptr_op(suffix, OP_EQ, NULL); + tt_str_op(format, OP_EQ, "Heartbeat: Tor's uptime is %s, with %d circuits open. " "I've sent %s and received %s.%s"); - tt_str_op(va_arg(ap, char *), ==, "0:00 hours"); /* uptime */ - tt_int_op(va_arg(ap, int), ==, 0); /* count_circuits() */ - tt_str_op(va_arg(ap, char *), ==, "0 kB"); /* bw_sent */ - tt_str_op(va_arg(ap, char *), ==, "0 kB"); /* bw_rcvd */ - tt_str_op(va_arg(ap, char *), ==, ""); /* hibernating */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0:00 hours"); /* uptime */ + tt_int_op(va_arg(ap, int), OP_EQ, 0); /* count_circuits() */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB"); /* bw_sent */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB"); /* bw_rcvd */ + tt_str_op(va_arg(ap, char *), OP_EQ, ""); /* hibernating */ break; case 1: - tt_int_op(severity, ==, LOG_NOTICE); - tt_int_op(domain, ==, LD_HEARTBEAT); - tt_ptr_op(strstr(funcname, "log_accounting"), !=, NULL); - tt_ptr_op(suffix, ==, NULL); - tt_str_op(format, ==, + tt_int_op(severity, OP_EQ, LOG_NOTICE); + tt_int_op(domain, OP_EQ, LD_HEARTBEAT); + tt_ptr_op(strstr(funcname, "log_accounting"), OP_NE, NULL); + tt_ptr_op(suffix, OP_EQ, NULL); + tt_str_op(format, OP_EQ, "Heartbeat: Accounting enabled. Sent: %s / %s, Received: %s / %s. " "The current accounting interval ends on %s, in %s."); - tt_str_op(va_arg(ap, char *), ==, "0 kB"); /* acc_sent */ - tt_str_op(va_arg(ap, char *), ==, "0 kB"); /* acc_max */ - tt_str_op(va_arg(ap, char *), ==, "0 kB"); /* acc_rcvd */ - tt_str_op(va_arg(ap, char *), ==, "0 kB"); /* acc_max */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB"); /* acc_sent */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB"); /* acc_max */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB"); /* acc_rcvd */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB"); /* acc_max */ /* format_local_iso_time uses local tz, just check mins and secs. */ - tt_ptr_op(strstr(va_arg(ap, char *), ":01:00"), !=, NULL); /* end_buf */ - tt_str_op(va_arg(ap, char *), ==, "0:01 hours"); /* remaining */ + tt_ptr_op(strstr(va_arg(ap, char *), ":01:00"), OP_NE, NULL); /* end_buf */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0:01 hours"); /* remaining */ break; default: tt_abort_msg("unexpected call to logv()"); // TODO: prettyprint args @@ -824,8 +824,8 @@ NS(test_main)(void *arg) expected = 0; actual = log_heartbeat(0);

- tt_int_op(actual, ==, expected); - tt_int_op(CALLED(logv), ==, 2); + tt_int_op(actual, OP_EQ, expected); + tt_int_op(CALLED(logv), OP_EQ, 2);

done: stats_n_data_bytes_packaged = 0; @@ -893,27 +893,27 @@ NS(logv)(int severity, log_domain_mask_t domain, const char *funcname, switch (CALLED(logv)) { case 0: - tt_int_op(severity, ==, LOG_NOTICE); - tt_int_op(domain, ==, LD_HEARTBEAT); - tt_ptr_op(strstr(funcname, "log_heartbeat"), !=, NULL); - tt_ptr_op(suffix, ==, NULL); - tt_str_op(format, ==, + tt_int_op(severity, OP_EQ, LOG_NOTICE); + tt_int_op(domain, OP_EQ, LD_HEARTBEAT); + tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL); + tt_ptr_op(suffix, OP_EQ, NULL); + tt_str_op(format, OP_EQ, "Heartbeat: Tor's uptime is %s, with %d circuits open. " "I've sent %s and received %s.%s"); - tt_str_op(va_arg(ap, char *), ==, "0:00 hours"); /* uptime */ - tt_int_op(va_arg(ap, int), ==, 0); /* count_circuits() */ - tt_str_op(va_arg(ap, char *), ==, "0 kB"); /* bw_sent */ - tt_str_op(va_arg(ap, char *), ==, "0 kB"); /* bw_rcvd */ - tt_str_op(va_arg(ap, char *), ==, ""); /* hibernating */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0:00 hours"); /* uptime */ + tt_int_op(va_arg(ap, int), OP_EQ, 0); /* count_circuits() */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB"); /* bw_sent */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB"); /* bw_rcvd */ + tt_str_op(va_arg(ap, char *), OP_EQ, ""); /* hibernating */ break; case 1: - tt_int_op(severity, ==, LOG_NOTICE); - tt_int_op(domain, ==, LD_HEARTBEAT); - tt_ptr_op(strstr(funcname, "log_heartbeat"), !=, NULL); - tt_ptr_op(suffix, ==, NULL); - tt_str_op(format, ==, + tt_int_op(severity, OP_EQ, LOG_NOTICE); + tt_int_op(domain, OP_EQ, LD_HEARTBEAT); + tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL); + tt_ptr_op(suffix, OP_EQ, NULL); + tt_str_op(format, OP_EQ, "Average packaged cell fullness: %2.3f%%"); - tt_int_op(fabs(va_arg(ap, double) - 100.0) <= DBL_EPSILON, ==, 1); + tt_int_op(fabs(va_arg(ap, double) - 100.0) <= DBL_EPSILON, OP_EQ, 1); break; default: tt_abort_msg("unexpected call to logv()"); // TODO: prettyprint args @@ -982,8 +982,8 @@ NS(test_main)(void *arg) expected = 0; actual = log_heartbeat(0);

- tt_int_op(actual, ==, expected); - tt_int_op(CALLED(logv), ==, 2); + tt_int_op(actual, OP_EQ, expected); + tt_int_op(CALLED(logv), OP_EQ, 2);

done: NS_UNMOCK(tls_get_write_overhead_ratio); @@ -1049,26 +1049,26 @@ NS(logv)(int severity, log_domain_mask_t domain, switch (CALLED(logv)) { case 0: - tt_int_op(severity, ==, LOG_NOTICE); - tt_int_op(domain, ==, LD_HEARTBEAT); - tt_ptr_op(strstr(funcname, "log_heartbeat"), !=, NULL); - tt_ptr_op(suffix, ==, NULL); - tt_str_op(format, ==, + tt_int_op(severity, OP_EQ, LOG_NOTICE); + tt_int_op(domain, OP_EQ, LD_HEARTBEAT); + tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL); + tt_ptr_op(suffix, OP_EQ, NULL); + tt_str_op(format, OP_EQ, "Heartbeat: Tor's uptime is %s, with %d circuits open. " "I've sent %s and received %s.%s"); - tt_str_op(va_arg(ap, char *), ==, "0:00 hours"); /* uptime */ - tt_int_op(va_arg(ap, int), ==, 0); /* count_circuits() */ - tt_str_op(va_arg(ap, char *), ==, "0 kB"); /* bw_sent */ - tt_str_op(va_arg(ap, char *), ==, "0 kB"); /* bw_rcvd */ - tt_str_op(va_arg(ap, char *), ==, ""); /* hibernating */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0:00 hours"); /* uptime */ + tt_int_op(va_arg(ap, int), OP_EQ, 0); /* count_circuits() */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB"); /* bw_sent */ + tt_str_op(va_arg(ap, char *), OP_EQ, "0 kB"); /* bw_rcvd */ + tt_str_op(va_arg(ap, char *), OP_EQ, ""); /* hibernating */ break; case 1: - tt_int_op(severity, ==, LOG_NOTICE); - tt_int_op(domain, ==, LD_HEARTBEAT); - tt_ptr_op(strstr(funcname, "log_heartbeat"), !=, NULL); - tt_ptr_op(suffix, ==, NULL); - tt_str_op(format, ==, "TLS write overhead: %.f%%"); - tt_int_op(fabs(va_arg(ap, double) - 100.0) <= DBL_EPSILON, ==, 1); + tt_int_op(severity, OP_EQ, LOG_NOTICE); + tt_int_op(domain, OP_EQ, LD_HEARTBEAT); + tt_ptr_op(strstr(funcname, "log_heartbeat"), OP_NE, NULL); + tt_ptr_op(suffix, OP_EQ, NULL); + tt_str_op(format, OP_EQ, "TLS write overhead: %.f%%"); + tt_int_op(fabs(va_arg(ap, double) - 100.0) <= DBL_EPSILON, OP_EQ, 1); break; default: tt_abort_msg("unexpected call to logv()"); // TODO: prettyprint args diff --git a/src/test/test_util.c b/src/test/test_util.c index 04dfe64..5211701 100644 --- a/src/test/test_util.c +++ b/src/test/test_util.c @@ -53,20 +53,20 @@ test_util_read_until_eof_impl(const char *fname, size_t file_len, crypto_rand(test_str, file_len);

r = write_bytes_to_file(fifo_name, test_str, file_len, 1); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0);

fd = open(fifo_name, O_RDONLY|O_BINARY); - tt_int_op(fd, >=, 0); + tt_int_op(fd, OP_GE, 0); str = read_file_to_str_until_eof(fd, read_limit, &sz); tt_assert(str != NULL);

if (read_limit < file_len) - tt_int_op(sz, ==, read_limit); + tt_int_op(sz, OP_EQ, read_limit); else - tt_int_op(sz, ==, file_len); + tt_int_op(sz, OP_EQ, file_len);

- tt_mem_op(test_str, ==, str, sz); - tt_int_op(str[sz], ==, '\0'); + tt_mem_op(test_str, OP_EQ, str, sz); + tt_int_op(str[sz], OP_EQ, '\0');

done: unlink(fifo_name); @@ -168,17 +168,17 @@ test_util_write_chunks_to_file(void *arg)

// write a known string to a file where the tempfile will be r = write_bytes_to_file(tempname, temp_str, temp_str_len, 1); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0);

// call write_chunks_to_file r = write_chunks_to_file(fname, chunks, 1, 0); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0);

// assert the file has been written (expected size) str = read_file_to_str(fname, RFTS_BIN, &st); tt_assert(str != NULL); - tt_u64_op((uint64_t)st.st_size, ==, data_str_len); - tt_mem_op(data_str, ==, str, data_str_len); + tt_u64_op((uint64_t)st.st_size, OP_EQ, data_str_len); + tt_mem_op(data_str, OP_EQ, str, data_str_len); tor_free(str);

// assert that the tempfile is removed (should not leave artifacts) @@ -187,7 +187,7 @@ test_util_write_chunks_to_file(void *arg)

// Remove old testfile for second test r = unlink(fname); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0); tor_free(fname); tor_free(tempname);

@@ -199,24 +199,24 @@ test_util_write_chunks_to_file(void *arg)

// write a known string to a file where the tempfile will be r = write_bytes_to_file(tempname, temp_str, temp_str_len, 1); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0);

// call write_chunks_to_file with no_tempfile = true r = write_chunks_to_file(fname, chunks, 1, 1); - tt_int_op(r, ==, 0); + tt_int_op(r, OP_EQ, 0);

// assert the file has been written (expected size) str = read_file_to_str(fname, RFTS_BIN, &st); tt_assert(str != NULL); - tt_u64_op((uint64_t)st.st_size, ==, data_str_len); - tt_mem_op(data_str, ==, str, data_str_len); + tt_u64_op((uint64_t)st.st_size, OP_EQ, data_str_len); + tt_mem_op(data_str, OP_EQ, str, data_str_len); tor_free(str);

// assert the tempfile still contains the known string str = read_file_to_str(tempname, RFTS_BIN, &st); tt_assert(str != NULL); - tt_u64_op((uint64_t)st.st_size, ==, temp_str_len); - tt_mem_op(temp_str, ==, str, temp_str_len); + tt_u64_op((uint64_t)st.st_size, OP_EQ, temp_str_len); + tt_mem_op(temp_str, OP_EQ, str, temp_str_len);

done: unlink(fname); @@ -229,7 +229,7 @@ test_util_write_chunks_to_file(void *arg) tor_free(temp_str); }

-#define _TFE(a, b, f) tt_int_op((a).f, ==, (b).f) +#define _TFE(a, b, f) tt_int_op((a).f, OP_EQ, (b).f) /** test the minimum set of struct tm fields needed for a unique epoch value * this is also the set we use to test tor_timegm */ #define TM_EQUAL(a, b) \ @@ -261,23 +261,23 @@ test_util_time(void *arg) end.tv_sec = 5; end.tv_usec = 5000;

- tt_int_op(0L,==, tv_udiff(&start, &end)); + tt_int_op(0L,OP_EQ, tv_udiff(&start, &end));

end.tv_usec = 7000;

- tt_int_op(2000L,==, tv_udiff(&start, &end)); + tt_int_op(2000L,OP_EQ, tv_udiff(&start, &end));

end.tv_sec = 6;

- tt_int_op(1002000L,==, tv_udiff(&start, &end)); + tt_int_op(1002000L,OP_EQ, tv_udiff(&start, &end));

end.tv_usec = 0;

- tt_int_op(995000L,==, tv_udiff(&start, &end)); + tt_int_op(995000L,OP_EQ, tv_udiff(&start, &end));

end.tv_sec = 4;

- tt_int_op(-1005000L,==, tv_udiff(&start, &end)); + tt_int_op(-1005000L,OP_EQ, tv_udiff(&start, &end));

/* Test tor_timegm & tor_gmtime_r */

@@ -299,26 +299,26 @@ test_util_time(void *arg) a_time.tm_min = 14; a_time.tm_sec = 55; t_res = 1062224095UL; - tt_int_op(t_res, ==, tor_timegm(&a_time)); + tt_int_op(t_res, OP_EQ, tor_timegm(&a_time)); tor_gmtime_r(&t_res, &b_time); TM_EQUAL(a_time, b_time);

a_time.tm_year = 2004-1900; /* Try a leap year, after feb. */ t_res = 1093846495UL; - tt_int_op(t_res, ==, tor_timegm(&a_time)); + tt_int_op(t_res, OP_EQ, tor_timegm(&a_time)); tor_gmtime_r(&t_res, &b_time); TM_EQUAL(a_time, b_time);

a_time.tm_mon = 1; /* Try a leap year, in feb. */ a_time.tm_mday = 10; t_res = 1076393695UL; - tt_int_op(t_res, ==, tor_timegm(&a_time)); + tt_int_op(t_res, OP_EQ, tor_timegm(&a_time)); tor_gmtime_r(&t_res, &b_time); TM_EQUAL(a_time, b_time);

a_time.tm_mon = 0; t_res = 1073715295UL; - tt_int_op(t_res, ==, tor_timegm(&a_time)); + tt_int_op(t_res, OP_EQ, tor_timegm(&a_time)); tor_gmtime_r(&t_res, &b_time); TM_EQUAL(a_time, b_time);

@@ -328,27 +328,27 @@ test_util_time(void *arg)

/* Wrong year < 1970 */ a_time.tm_year = 1969-1900; - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

a_time.tm_year = -1-1900; - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

#if SIZEOF_INT == 4 || SIZEOF_INT == 8 a_time.tm_year = -1*(1 << 16); - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

/* one of the smallest tm_year values my 64 bit system supports: * t_res = -9223372036854775LL without clamping */ a_time.tm_year = -292275055-1900; - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

a_time.tm_year = INT32_MIN; - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time)); #endif

#if SIZEOF_INT == 8 a_time.tm_year = -1*(1 << 48); - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

/* while unlikely, the system's gmtime(_r) could return * a "correct" retrospective gregorian negative year value, @@ -356,25 +356,25 @@ test_util_time(void *arg) * -1*(2^63)/60/60/24*2000/730485 + 1970 = -292277022657 * 730485 is the number of days in two millenia, including leap days */ a_time.tm_year = -292277022657-1900; - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

a_time.tm_year = INT64_MIN; - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time)); #endif

/* Wrong year >= INT32_MAX - 1900 */ #if SIZEOF_INT == 4 || SIZEOF_INT == 8 a_time.tm_year = INT32_MAX-1900; - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

a_time.tm_year = INT32_MAX; - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time)); #endif

#if SIZEOF_INT == 8 /* one of the largest tm_year values my 64 bit system supports */ a_time.tm_year = 292278994-1900; - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

/* while unlikely, the system's gmtime(_r) could return * a "correct" proleptic gregorian year value, @@ -382,72 +382,72 @@ test_util_time(void *arg) * (2^63-1)/60/60/24*2000/730485 + 1970 = 292277026596 * 730485 is the number of days in two millenia, including leap days */ a_time.tm_year = 292277026596-1900; - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

a_time.tm_year = INT64_MAX-1900; - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

a_time.tm_year = INT64_MAX; - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time)); #endif

/* month */ a_time.tm_year = 2007-1900; /* restore valid year */

a_time.tm_mon = 12; /* Wrong month, it's 0-based */ - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

a_time.tm_mon = -1; /* Wrong month */ - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

/* day */ a_time.tm_mon = 6; /* Try July */ a_time.tm_mday = 32; /* Wrong day */ - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

a_time.tm_mon = 5; /* Try June */ a_time.tm_mday = 31; /* Wrong day */ - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

a_time.tm_year = 2008-1900; /* Try a leap year */ a_time.tm_mon = 1; /* in feb. */ a_time.tm_mday = 30; /* Wrong day */ - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

a_time.tm_year = 2011-1900; /* Try a non-leap year */ a_time.tm_mon = 1; /* in feb. */ a_time.tm_mday = 29; /* Wrong day */ - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

a_time.tm_mday = 0; /* Wrong day, it's 1-based (to be different) */ - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

/* hour */ a_time.tm_mday = 3; /* restore valid month day */

a_time.tm_hour = 24; /* Wrong hour, it's 0-based */ - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

a_time.tm_hour = -1; /* Wrong hour */ - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

/* minute */ a_time.tm_hour = 22; /* restore valid hour */

a_time.tm_min = 60; /* Wrong minute, it's 0-based */ - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

a_time.tm_min = -1; /* Wrong minute */ - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

/* second */ a_time.tm_min = 37; /* restore valid minute */

a_time.tm_sec = 61; /* Wrong second: 0-based with leap seconds */ - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

a_time.tm_sec = -1; /* Wrong second */ - tt_int_op((time_t) -1,==, tor_timegm(&a_time)); + tt_int_op((time_t) -1,OP_EQ, tor_timegm(&a_time));

/* Test tor_gmtime_r out of range */

@@ -534,69 +534,69 @@ test_util_time(void *arg) /* Test {format,parse}_rfc1123_time */

format_rfc1123_time(timestr, 0); - tt_str_op("Thu, 01 Jan 1970 00:00:00 GMT",==, timestr); + tt_str_op("Thu, 01 Jan 1970 00:00:00 GMT",OP_EQ, timestr); format_rfc1123_time(timestr, (time_t)1091580502UL); - tt_str_op("Wed, 04 Aug 2004 00:48:22 GMT",==, timestr); + tt_str_op("Wed, 04 Aug 2004 00:48:22 GMT",OP_EQ, timestr);

t_res = 0; i = parse_rfc1123_time(timestr, &t_res); - tt_int_op(0,==, i); - tt_int_op(t_res,==, (time_t)1091580502UL); + tt_int_op(0,OP_EQ, i); + tt_int_op(t_res,OP_EQ, (time_t)1091580502UL); /* The timezone doesn't matter */ t_res = 0; - tt_int_op(0,==, parse_rfc1123_time("Wed, 04 Aug 2004 00:48:22 ZUL", &t_res)); - tt_int_op(t_res,==, (time_t)1091580502UL); - tt_int_op(-1,==, + tt_int_op(0,OP_EQ, parse_rfc1123_time("Wed, 04 Aug 2004 00:48:22 ZUL", &t_res)); + tt_int_op(t_res,OP_EQ, (time_t)1091580502UL); + tt_int_op(-1,OP_EQ, parse_rfc1123_time("Wed, zz Aug 2004 99-99x99 GMT", &t_res)); - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, parse_rfc1123_time("Wed, 32 Mar 2011 00:00:00 GMT", &t_res)); - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, parse_rfc1123_time("Wed, 30 Mar 2011 24:00:00 GMT", &t_res)); - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, parse_rfc1123_time("Wed, 30 Mar 2011 23:60:00 GMT", &t_res)); - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, parse_rfc1123_time("Wed, 30 Mar 2011 23:59:62 GMT", &t_res)); - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, parse_rfc1123_time("Wed, 30 Mar 1969 23:59:59 GMT", &t_res)); - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, parse_rfc1123_time("Wed, 30 Ene 2011 23:59:59 GMT", &t_res)); - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, parse_rfc1123_time("Wed, 30 Mar 2011 23:59:59 GM", &t_res));

- tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, parse_rfc1123_time("Wed, 29 Feb 2011 16:00:00 GMT", &t_res)); - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, parse_rfc1123_time("Wed, 30 Mar 2011 23:59:61 GMT", &t_res));

/* Test parse_iso_time */

t_res = 0; i = parse_iso_time("", &t_res); - tt_int_op(-1,==, i); + tt_int_op(-1,OP_EQ, i); t_res = 0; i = parse_iso_time("2004-08-32 00:48:22", &t_res); - tt_int_op(-1,==, i); + tt_int_op(-1,OP_EQ, i); t_res = 0; i = parse_iso_time("1969-08-03 00:48:22", &t_res); - tt_int_op(-1,==, i); + tt_int_op(-1,OP_EQ, i);

t_res = 0; i = parse_iso_time("2004-08-04 00:48:22", &t_res); - tt_int_op(0,==, i); - tt_int_op(t_res,==, (time_t)1091580502UL); + tt_int_op(0,OP_EQ, i); + tt_int_op(t_res,OP_EQ, (time_t)1091580502UL); t_res = 0; i = parse_iso_time("2004-8-4 0:48:22", &t_res); - tt_int_op(0,==, i); - tt_int_op(t_res,==, (time_t)1091580502UL); - tt_int_op(-1,==, parse_iso_time("2004-08-zz 99-99x99 GMT", &t_res)); - tt_int_op(-1,==, parse_iso_time("2011-03-32 00:00:00 GMT", &t_res)); - tt_int_op(-1,==, parse_iso_time("2011-03-30 24:00:00 GMT", &t_res)); - tt_int_op(-1,==, parse_iso_time("2011-03-30 23:60:00 GMT", &t_res)); - tt_int_op(-1,==, parse_iso_time("2011-03-30 23:59:62 GMT", &t_res)); - tt_int_op(-1,==, parse_iso_time("1969-03-30 23:59:59 GMT", &t_res)); - tt_int_op(-1,==, parse_iso_time("2011-00-30 23:59:59 GMT", &t_res)); - tt_int_op(-1,==, parse_iso_time("2147483647-08-29 14:00:00", &t_res)); - tt_int_op(-1,==, parse_iso_time("2011-03-30 23:59", &t_res)); + tt_int_op(0,OP_EQ, i); + tt_int_op(t_res,OP_EQ, (time_t)1091580502UL); + tt_int_op(-1,OP_EQ, parse_iso_time("2004-08-zz 99-99x99 GMT", &t_res)); + tt_int_op(-1,OP_EQ, parse_iso_time("2011-03-32 00:00:00 GMT", &t_res)); + tt_int_op(-1,OP_EQ, parse_iso_time("2011-03-30 24:00:00 GMT", &t_res)); + tt_int_op(-1,OP_EQ, parse_iso_time("2011-03-30 23:60:00 GMT", &t_res)); + tt_int_op(-1,OP_EQ, parse_iso_time("2011-03-30 23:59:62 GMT", &t_res)); + tt_int_op(-1,OP_EQ, parse_iso_time("1969-03-30 23:59:59 GMT", &t_res)); + tt_int_op(-1,OP_EQ, parse_iso_time("2011-00-30 23:59:59 GMT", &t_res)); + tt_int_op(-1,OP_EQ, parse_iso_time("2147483647-08-29 14:00:00", &t_res)); + tt_int_op(-1,OP_EQ, parse_iso_time("2011-03-30 23:59", &t_res));

/* Test tor_gettimeofday */

@@ -609,14 +609,14 @@ test_util_time(void *arg) /* now make sure time works. */ tor_gettimeofday(&end); /* We might've timewarped a little. */ - tt_int_op(tv_udiff(&start, &end), >=, -5000); + tt_int_op(tv_udiff(&start, &end), OP_GE, -5000);

/* Test format_iso_time */

tv.tv_sec = (time_t)1326296338; tv.tv_usec = 3060; format_iso_time(timestr, (time_t)tv.tv_sec); - tt_str_op("2012-01-11 15:38:58",==, timestr); + tt_str_op("2012-01-11 15:38:58",OP_EQ, timestr); /* The output of format_local_iso_time will vary by timezone, and setting our timezone for testing purposes would be a nontrivial flaky pain. Skip this test for now. @@ -624,11 +624,11 @@ test_util_time(void *arg) test_streq("2012-01-11 10:38:58", timestr); */ format_iso_time_nospace(timestr, (time_t)tv.tv_sec); - tt_str_op("2012-01-11T15:38:58",==, timestr); - tt_int_op(strlen(timestr),==, ISO_TIME_LEN); + tt_str_op("2012-01-11T15:38:58",OP_EQ, timestr); + tt_int_op(strlen(timestr),OP_EQ, ISO_TIME_LEN); format_iso_time_nospace_usec(timestr, &tv); - tt_str_op("2012-01-11T15:38:58.003060",==, timestr); - tt_int_op(strlen(timestr),==, ISO_TIME_USEC_LEN); + tt_str_op("2012-01-11T15:38:58.003060",OP_EQ, timestr); + tt_int_op(strlen(timestr),OP_EQ, ISO_TIME_USEC_LEN);

done: ; @@ -643,72 +643,72 @@ test_util_parse_http_time(void *arg)

#define T(s) do { \ format_iso_time(b, tor_timegm(&a_time)); \ - tt_str_op(b, ==, (s)); \ + tt_str_op(b, OP_EQ, (s)); \ b[0]='\0'; \ } while (0)

/* Test parse_http_time */

- tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, parse_http_time("", &a_time)); - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, parse_http_time("Sunday, 32 Aug 2004 00:48:22 GMT", &a_time)); - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, parse_http_time("Sunday, 3 Aug 1869 00:48:22 GMT", &a_time)); - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, parse_http_time("Sunday, 32-Aug-94 00:48:22 GMT", &a_time)); - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, parse_http_time("Sunday, 3-Ago-04 00:48:22", &a_time)); - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, parse_http_time("Sunday, August the third", &a_time)); - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, parse_http_time("Wednesday,,04 Aug 1994 00:48:22 GMT", &a_time));

- tt_int_op(0,==, + tt_int_op(0,OP_EQ, parse_http_time("Wednesday, 04 Aug 1994 00:48:22 GMT", &a_time)); - tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time)); + tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time)); T("1994-08-04 00:48:22"); - tt_int_op(0,==, + tt_int_op(0,OP_EQ, parse_http_time("Wednesday, 4 Aug 1994 0:48:22 GMT", &a_time)); - tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time)); + tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time)); T("1994-08-04 00:48:22"); - tt_int_op(0,==, + tt_int_op(0,OP_EQ, parse_http_time("Miercoles, 4 Aug 1994 0:48:22 GMT", &a_time)); - tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time)); + tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time)); T("1994-08-04 00:48:22"); - tt_int_op(0,==, + tt_int_op(0,OP_EQ, parse_http_time("Wednesday, 04-Aug-94 00:48:22 GMT", &a_time)); - tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time)); + tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time)); T("1994-08-04 00:48:22"); - tt_int_op(0,==, parse_http_time("Wednesday, 4-Aug-94 0:48:22 GMT", &a_time)); - tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time)); + tt_int_op(0,OP_EQ, parse_http_time("Wednesday, 4-Aug-94 0:48:22 GMT", &a_time)); + tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time)); T("1994-08-04 00:48:22"); - tt_int_op(0,==, parse_http_time("Miercoles, 4-Aug-94 0:48:22 GMT", &a_time)); - tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time)); + tt_int_op(0,OP_EQ, parse_http_time("Miercoles, 4-Aug-94 0:48:22 GMT", &a_time)); + tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time)); T("1994-08-04 00:48:22"); - tt_int_op(0,==, parse_http_time("Wed Aug 04 00:48:22 1994", &a_time)); - tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time)); + tt_int_op(0,OP_EQ, parse_http_time("Wed Aug 04 00:48:22 1994", &a_time)); + tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time)); T("1994-08-04 00:48:22"); - tt_int_op(0,==, parse_http_time("Wed Aug 4 0:48:22 1994", &a_time)); - tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time)); + tt_int_op(0,OP_EQ, parse_http_time("Wed Aug 4 0:48:22 1994", &a_time)); + tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time)); T("1994-08-04 00:48:22"); - tt_int_op(0,==, parse_http_time("Mie Aug 4 0:48:22 1994", &a_time)); - tt_int_op((time_t)775961302UL,==, tor_timegm(&a_time)); + tt_int_op(0,OP_EQ, parse_http_time("Mie Aug 4 0:48:22 1994", &a_time)); + tt_int_op((time_t)775961302UL,OP_EQ, tor_timegm(&a_time)); T("1994-08-04 00:48:22"); - tt_int_op(0,==, parse_http_time("Sun, 1 Jan 2012 00:00:00 GMT", &a_time)); - tt_int_op((time_t)1325376000UL,==, tor_timegm(&a_time)); + tt_int_op(0,OP_EQ, parse_http_time("Sun, 1 Jan 2012 00:00:00 GMT", &a_time)); + tt_int_op((time_t)1325376000UL,OP_EQ, tor_timegm(&a_time)); T("2012-01-01 00:00:00"); - tt_int_op(0,==, parse_http_time("Mon, 31 Dec 2012 00:00:00 GMT", &a_time)); - tt_int_op((time_t)1356912000UL,==, tor_timegm(&a_time)); + tt_int_op(0,OP_EQ, parse_http_time("Mon, 31 Dec 2012 00:00:00 GMT", &a_time)); + tt_int_op((time_t)1356912000UL,OP_EQ, tor_timegm(&a_time)); T("2012-12-31 00:00:00"); - tt_int_op(-1,==, parse_http_time("2004-08-zz 99-99x99 GMT", &a_time)); - tt_int_op(-1,==, parse_http_time("2011-03-32 00:00:00 GMT", &a_time)); - tt_int_op(-1,==, parse_http_time("2011-03-30 24:00:00 GMT", &a_time)); - tt_int_op(-1,==, parse_http_time("2011-03-30 23:60:00 GMT", &a_time)); - tt_int_op(-1,==, parse_http_time("2011-03-30 23:59:62 GMT", &a_time)); - tt_int_op(-1,==, parse_http_time("1969-03-30 23:59:59 GMT", &a_time)); - tt_int_op(-1,==, parse_http_time("2011-00-30 23:59:59 GMT", &a_time)); - tt_int_op(-1,==, parse_http_time("2011-03-30 23:59", &a_time)); + tt_int_op(-1,OP_EQ, parse_http_time("2004-08-zz 99-99x99 GMT", &a_time)); + tt_int_op(-1,OP_EQ, parse_http_time("2011-03-32 00:00:00 GMT", &a_time)); + tt_int_op(-1,OP_EQ, parse_http_time("2011-03-30 24:00:00 GMT", &a_time)); + tt_int_op(-1,OP_EQ, parse_http_time("2011-03-30 23:60:00 GMT", &a_time)); + tt_int_op(-1,OP_EQ, parse_http_time("2011-03-30 23:59:62 GMT", &a_time)); + tt_int_op(-1,OP_EQ, parse_http_time("1969-03-30 23:59:59 GMT", &a_time)); + tt_int_op(-1,OP_EQ, parse_http_time("2011-00-30 23:59:59 GMT", &a_time)); + tt_int_op(-1,OP_EQ, parse_http_time("2011-03-30 23:59", &a_time));

#undef T done: @@ -743,110 +743,110 @@ test_util_config_line(void *arg) str = buf;

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k"); - tt_str_op(v,==, "v"); + tt_str_op(k,OP_EQ, "k"); + tt_str_op(v,OP_EQ, "v"); tor_free(k); tor_free(v); tt_assert(!strcmpstart(str, "key value with"));

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "key"); - tt_str_op(v,==, "value with spaces"); + tt_str_op(k,OP_EQ, "key"); + tt_str_op(v,OP_EQ, "value with spaces"); tor_free(k); tor_free(v); tt_assert(!strcmpstart(str, "keykey"));

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "keykey"); - tt_str_op(v,==, "val"); + tt_str_op(k,OP_EQ, "keykey"); + tt_str_op(v,OP_EQ, "val"); tor_free(k); tor_free(v); tt_assert(!strcmpstart(str, "k2\n"));

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k2"); - tt_str_op(v,==, ""); + tt_str_op(k,OP_EQ, "k2"); + tt_str_op(v,OP_EQ, ""); tor_free(k); tor_free(v); tt_assert(!strcmpstart(str, "k3 \n"));

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k3"); - tt_str_op(v,==, ""); + tt_str_op(k,OP_EQ, "k3"); + tt_str_op(v,OP_EQ, ""); tor_free(k); tor_free(v); tt_assert(!strcmpstart(str, "#comment"));

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k4"); - tt_str_op(v,==, ""); + tt_str_op(k,OP_EQ, "k4"); + tt_str_op(v,OP_EQ, ""); tor_free(k); tor_free(v); tt_assert(!strcmpstart(str, "k5#abc"));

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k5"); - tt_str_op(v,==, ""); + tt_str_op(k,OP_EQ, "k5"); + tt_str_op(v,OP_EQ, ""); tor_free(k); tor_free(v); tt_assert(!strcmpstart(str, "k6"));

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k6"); - tt_str_op(v,==, "val"); + tt_str_op(k,OP_EQ, "k6"); + tt_str_op(v,OP_EQ, "val"); tor_free(k); tor_free(v); tt_assert(!strcmpstart(str, "kseven"));

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "kseven"); - tt_str_op(v,==, "a quoted 'string"); + tt_str_op(k,OP_EQ, "kseven"); + tt_str_op(v,OP_EQ, "a quoted 'string"); tor_free(k); tor_free(v); tt_assert(!strcmpstart(str, "k8 "));

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k8"); - tt_str_op(v,==, "a quoted\n"str\ing\t\x01\x01\x01""); + tt_str_op(k,OP_EQ, "k8"); + tt_str_op(v,OP_EQ, "a quoted\n"str\ing\t\x01\x01\x01""); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k9"); - tt_str_op(v,==, "a line that spans two lines."); + tt_str_op(k,OP_EQ, "k9"); + tt_str_op(v,OP_EQ, "a line that spans two lines."); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k10"); - tt_str_op(v,==, "more than one continuation"); + tt_str_op(k,OP_EQ, "k10"); + tt_str_op(v,OP_EQ, "more than one continuation"); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k11"); - tt_str_op(v,==, "continuation at the start"); + tt_str_op(k,OP_EQ, "k11"); + tt_str_op(v,OP_EQ, "continuation at the start"); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k12"); - tt_str_op(v,==, "line with a embedded"); + tt_str_op(k,OP_EQ, "k12"); + tt_str_op(v,OP_EQ, "line with a embedded"); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k13"); - tt_str_op(v,==, "continuation at the very start"); + tt_str_op(k,OP_EQ, "k13"); + tt_str_op(v,OP_EQ, "continuation at the very start"); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k14"); - tt_str_op(v,==, "a line that has a comment and" ); + tt_str_op(k,OP_EQ, "k14"); + tt_str_op(v,OP_EQ, "a line that has a comment and" ); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k15"); - tt_str_op(v,==, "this should be the next new line"); + tt_str_op(k,OP_EQ, "k15"); + tt_str_op(v,OP_EQ, "this should be the next new line"); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k16"); - tt_str_op(v,==, "a line that has a comment and" ); + tt_str_op(k,OP_EQ, "k16"); + tt_str_op(v,OP_EQ, "a line that has a comment and" ); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k17"); - tt_str_op(v,==, "this should be the next new line"); + tt_str_op(k,OP_EQ, "k17"); + tt_str_op(v,OP_EQ, "this should be the next new line"); tor_free(k); tor_free(v);

- tt_str_op(str,==, ""); + tt_str_op(str,OP_EQ, "");

done: tor_free(k); @@ -877,30 +877,30 @@ test_util_config_line_quotes(void *arg) str = buf1;

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "kTrailingSpace"); - tt_str_op(v,==, "quoted value"); + tt_str_op(k,OP_EQ, "kTrailingSpace"); + tt_str_op(v,OP_EQ, "quoted value"); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_ptr_op(str,==, NULL); + tt_ptr_op(str,OP_EQ, NULL); tor_free(k); tor_free(v);

str = buf2;

str = parse_config_line_from_str(str, &k, &v); - tt_ptr_op(str,==, NULL); + tt_ptr_op(str,OP_EQ, NULL); tor_free(k); tor_free(v);

str = buf3;

str = parse_config_line_from_str(str, &k, &v); - tt_ptr_op(str,==, NULL); + tt_ptr_op(str,OP_EQ, NULL); tor_free(k); tor_free(v);

str = buf4;

str = parse_config_line_from_str(str, &k, &v); - tt_ptr_op(str,==, NULL); + tt_ptr_op(str,OP_EQ, NULL); tor_free(k); tor_free(v);

done: @@ -924,16 +924,16 @@ test_util_config_line_comment_character(void *arg) str = buf;

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k1"); - tt_str_op(v,==, "# in quotes"); + tt_str_op(k,OP_EQ, "k1"); + tt_str_op(v,OP_EQ, "# in quotes"); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "k2"); - tt_str_op(v,==, "some value"); + tt_str_op(k,OP_EQ, "k2"); + tt_str_op(v,OP_EQ, "some value"); tor_free(k); tor_free(v);

- tt_str_op(str,==, "k3 /home/user/myTorNetwork#2\n"); + tt_str_op(str,OP_EQ, "k3 /home/user/myTorNetwork#2\n");

#if 0 str = parse_config_line_from_str(str, &k, &v); @@ -994,91 +994,91 @@ test_util_config_line_escaped_content(void *arg) str = buf1;

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "HexadecimalLower"); - tt_str_op(v,==, "*"); + tt_str_op(k,OP_EQ, "HexadecimalLower"); + tt_str_op(v,OP_EQ, "*"); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "HexadecimalUpper"); - tt_str_op(v,==, "*"); + tt_str_op(k,OP_EQ, "HexadecimalUpper"); + tt_str_op(v,OP_EQ, "*"); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "HexadecimalUpperX"); - tt_str_op(v,==, "*"); + tt_str_op(k,OP_EQ, "HexadecimalUpperX"); + tt_str_op(v,OP_EQ, "*"); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "Octal"); - tt_str_op(v,==, "*"); + tt_str_op(k,OP_EQ, "Octal"); + tt_str_op(v,OP_EQ, "*"); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "Newline"); - tt_str_op(v,==, "\n"); + tt_str_op(k,OP_EQ, "Newline"); + tt_str_op(v,OP_EQ, "\n"); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "Tab"); - tt_str_op(v,==, "\t"); + tt_str_op(k,OP_EQ, "Tab"); + tt_str_op(v,OP_EQ, "\t"); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "CarriageReturn"); - tt_str_op(v,==, "\r"); + tt_str_op(k,OP_EQ, "CarriageReturn"); + tt_str_op(v,OP_EQ, "\r"); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "DoubleQuote"); - tt_str_op(v,==, """); + tt_str_op(k,OP_EQ, "DoubleQuote"); + tt_str_op(v,OP_EQ, """); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "SimpleQuote"); - tt_str_op(v,==, "'"); + tt_str_op(k,OP_EQ, "SimpleQuote"); + tt_str_op(v,OP_EQ, "'"); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "Backslash"); - tt_str_op(v,==, "\"); + tt_str_op(k,OP_EQ, "Backslash"); + tt_str_op(v,OP_EQ, "\"); tor_free(k); tor_free(v);

str = parse_config_line_from_str(str, &k, &v); - tt_str_op(k,==, "Mix"); - tt_str_op(v,==, "This is a "star":\t'*'\nAnd second line"); + tt_str_op(k,OP_EQ, "Mix"); + tt_str_op(v,OP_EQ, "This is a "star":\t'*'\nAnd second line"); tor_free(k); tor_free(v); - tt_str_op(str,==, ""); + tt_str_op(str,OP_EQ, "");

str = buf2;

str = parse_config_line_from_str(str, &k, &v); - tt_ptr_op(str,==, NULL); + tt_ptr_op(str,OP_EQ, NULL); tor_free(k); tor_free(v);

str = buf3;

str = parse_config_line_from_str(str, &k, &v); - tt_ptr_op(str,==, NULL); + tt_ptr_op(str,OP_EQ, NULL); tor_free(k); tor_free(v);

str = buf4;

str = parse_config_line_from_str(str, &k, &v); - tt_ptr_op(str,==, NULL); + tt_ptr_op(str,OP_EQ, NULL); tor_free(k); tor_free(v);

#if 0 str = buf5;

str = parse_config_line_from_str(str, &k, &v); - tt_ptr_op(str, ==, NULL); + tt_ptr_op(str, OP_EQ, NULL); tor_free(k); tor_free(v); #endif

str = buf6;

str = parse_config_line_from_str(str, &k, &v); - tt_ptr_op(str,==, NULL); + tt_ptr_op(str,OP_EQ, NULL); tor_free(k); tor_free(v);

done: @@ -1096,39 +1096,39 @@ test_util_expand_filename(void *arg) setenv("HOME", "/home/itv", 1); /* For "internal test value" */

str = expand_filename(""); - tt_str_op("",==, str); + tt_str_op("",OP_EQ, str); tor_free(str);

str = expand_filename("/normal/path"); - tt_str_op("/normal/path",==, str); + tt_str_op("/normal/path",OP_EQ, str); tor_free(str);

str = expand_filename("/normal/trailing/path/"); - tt_str_op("/normal/trailing/path/",==, str); + tt_str_op("/normal/trailing/path/",OP_EQ, str); tor_free(str);

str = expand_filename("~"); - tt_str_op("/home/itv/",==, str); + tt_str_op("/home/itv/",OP_EQ, str); tor_free(str);

str = expand_filename("$HOME/nodice"); - tt_str_op("$HOME/nodice",==, str); + tt_str_op("$HOME/nodice",OP_EQ, str); tor_free(str);

str = expand_filename("~/"); - tt_str_op("/home/itv/",==, str); + tt_str_op("/home/itv/",OP_EQ, str); tor_free(str);

str = expand_filename("~/foobarqux"); - tt_str_op("/home/itv/foobarqux",==, str); + tt_str_op("/home/itv/foobarqux",OP_EQ, str); tor_free(str);

str = expand_filename("~/../../etc/passwd"); - tt_str_op("/home/itv/../../etc/passwd",==, str); + tt_str_op("/home/itv/../../etc/passwd",OP_EQ, str); tor_free(str);

str = expand_filename("~/trailing/"); - tt_str_op("/home/itv/trailing/",==, str); + tt_str_op("/home/itv/trailing/",OP_EQ, str); tor_free(str); /* Ideally we'd test ~anotheruser, but that's shady to test (we'd have to somehow inject/fake the get_user_homedir call) */ @@ -1137,15 +1137,15 @@ test_util_expand_filename(void *arg) setenv("HOME", "/home/itv/", 1);

str = expand_filename("~"); - tt_str_op("/home/itv/",==, str); + tt_str_op("/home/itv/",OP_EQ, str); tor_free(str);

str = expand_filename("~/"); - tt_str_op("/home/itv/",==, str); + tt_str_op("/home/itv/",OP_EQ, str); tor_free(str);

str = expand_filename("~/foo"); - tt_str_op("/home/itv/foo",==, str); + tt_str_op("/home/itv/foo",OP_EQ, str); tor_free(str);

/* Try with empty $HOME */ @@ -1153,15 +1153,15 @@ test_util_expand_filename(void *arg) setenv("HOME", "", 1);

str = expand_filename("~"); - tt_str_op("/",==, str); + tt_str_op("/",OP_EQ, str); tor_free(str);

str = expand_filename("~/"); - tt_str_op("/",==, str); + tt_str_op("/",OP_EQ, str); tor_free(str);

str = expand_filename("~/foobar"); - tt_str_op("/foobar",==, str); + tt_str_op("/foobar",OP_EQ, str); tor_free(str);

/* Try with $HOME unset */ @@ -1169,15 +1169,15 @@ test_util_expand_filename(void *arg) unsetenv("HOME");

str = expand_filename("~"); - tt_str_op("/",==, str); + tt_str_op("/",OP_EQ, str); tor_free(str);

str = expand_filename("~/"); - tt_str_op("/",==, str); + tt_str_op("/",OP_EQ, str); tor_free(str);

str = expand_filename("~/foobar"); - tt_str_op("/foobar",==, str); + tt_str_op("/foobar",OP_EQ, str); tor_free(str);

done: @@ -1195,30 +1195,30 @@ test_util_escape_string_socks(void *arg) (void)arg; escaped_string = tor_escape_str_for_pt_args("This is a backslash: \",";\"); tt_assert(escaped_string); - tt_str_op(escaped_string,==, "This is a backslash: \\"); + tt_str_op(escaped_string,OP_EQ, "This is a backslash: \\"); tor_free(escaped_string);

/** Simple semicolon escape. */ escaped_string = tor_escape_str_for_pt_args("First rule:Do not use ;",";\"); tt_assert(escaped_string); - tt_str_op(escaped_string,==, "First rule:Do not use \;"); + tt_str_op(escaped_string,OP_EQ, "First rule:Do not use \;"); tor_free(escaped_string);

/** Empty string. */ escaped_string = tor_escape_str_for_pt_args("", ";\"); tt_assert(escaped_string); - tt_str_op(escaped_string,==, ""); + tt_str_op(escaped_string,OP_EQ, ""); tor_free(escaped_string);

/** Escape all characters. */ escaped_string = tor_escape_str_for_pt_args(";\;\", ";\"); tt_assert(escaped_string); - tt_str_op(escaped_string,==, "\;\\\;\\"); + tt_str_op(escaped_string,OP_EQ, "\;\\\;\\"); tor_free(escaped_string);

escaped_string = tor_escape_str_for_pt_args(";", ";\"); tt_assert(escaped_string); - tt_str_op(escaped_string,==, "\;"); + tt_str_op(escaped_string,OP_EQ, "\;"); tor_free(escaped_string);

done: @@ -1254,152 +1254,152 @@ test_util_strmisc(void *arg)

/* Test strl operations */ (void)arg; - tt_int_op(5,==, strlcpy(buf, "Hello", 0)); - tt_int_op(5,==, strlcpy(buf, "Hello", 10)); - tt_str_op(buf,==, "Hello"); - tt_int_op(5,==, strlcpy(buf, "Hello", 6)); - tt_str_op(buf,==, "Hello"); - tt_int_op(5,==, strlcpy(buf, "Hello", 5)); - tt_str_op(buf,==, "Hell"); + tt_int_op(5,OP_EQ, strlcpy(buf, "Hello", 0)); + tt_int_op(5,OP_EQ, strlcpy(buf, "Hello", 10)); + tt_str_op(buf,OP_EQ, "Hello"); + tt_int_op(5,OP_EQ, strlcpy(buf, "Hello", 6)); + tt_str_op(buf,OP_EQ, "Hello"); + tt_int_op(5,OP_EQ, strlcpy(buf, "Hello", 5)); + tt_str_op(buf,OP_EQ, "Hell"); strlcpy(buf, "Hello", sizeof(buf)); - tt_int_op(10,==, strlcat(buf, "Hello", 5)); + tt_int_op(10,OP_EQ, strlcat(buf, "Hello", 5));

/* Test strstrip() */ strlcpy(buf, "Testing 1 2 3", sizeof(buf)); tor_strstrip(buf, ",!"); - tt_str_op(buf,==, "Testing 1 2 3"); + tt_str_op(buf,OP_EQ, "Testing 1 2 3"); strlcpy(buf, "!Testing 1 2 3?", sizeof(buf)); tor_strstrip(buf, "!? "); - tt_str_op(buf,==, "Testing123"); + tt_str_op(buf,OP_EQ, "Testing123"); strlcpy(buf, "!!!Testing 1 2 3??", sizeof(buf)); tor_strstrip(buf, "!? "); - tt_str_op(buf,==, "Testing123"); + tt_str_op(buf,OP_EQ, "Testing123");

/* Test parse_long */ /* Empty/zero input */ - tt_int_op(0L,==, tor_parse_long("",10,0,100,&i,NULL)); - tt_int_op(0,==, i); - tt_int_op(0L,==, tor_parse_long("0",10,0,100,&i,NULL)); - tt_int_op(1,==, i); + tt_int_op(0L,OP_EQ, tor_parse_long("",10,0,100,&i,NULL)); + tt_int_op(0,OP_EQ, i); + tt_int_op(0L,OP_EQ, tor_parse_long("0",10,0,100,&i,NULL)); + tt_int_op(1,OP_EQ, i); /* Normal cases */ - tt_int_op(10L,==, tor_parse_long("10",10,0,100,&i,NULL)); - tt_int_op(1,==, i); - tt_int_op(10L,==, tor_parse_long("10",10,0,10,&i,NULL)); - tt_int_op(1,==, i); - tt_int_op(10L,==, tor_parse_long("10",10,10,100,&i,NULL)); - tt_int_op(1,==, i); - tt_int_op(-50L,==, tor_parse_long("-50",10,-100,100,&i,NULL)); - tt_int_op(1,==, i); - tt_int_op(-50L,==, tor_parse_long("-50",10,-100,0,&i,NULL)); - tt_int_op(1,==, i); - tt_int_op(-50L,==, tor_parse_long("-50",10,-50,0,&i,NULL)); - tt_int_op(1,==, i); + tt_int_op(10L,OP_EQ, tor_parse_long("10",10,0,100,&i,NULL)); + tt_int_op(1,OP_EQ, i); + tt_int_op(10L,OP_EQ, tor_parse_long("10",10,0,10,&i,NULL)); + tt_int_op(1,OP_EQ, i); + tt_int_op(10L,OP_EQ, tor_parse_long("10",10,10,100,&i,NULL)); + tt_int_op(1,OP_EQ, i); + tt_int_op(-50L,OP_EQ, tor_parse_long("-50",10,-100,100,&i,NULL)); + tt_int_op(1,OP_EQ, i); + tt_int_op(-50L,OP_EQ, tor_parse_long("-50",10,-100,0,&i,NULL)); + tt_int_op(1,OP_EQ, i); + tt_int_op(-50L,OP_EQ, tor_parse_long("-50",10,-50,0,&i,NULL)); + tt_int_op(1,OP_EQ, i); /* Extra garbage */ - tt_int_op(0L,==, tor_parse_long("10m",10,0,100,&i,NULL)); - tt_int_op(0,==, i); - tt_int_op(0L,==, tor_parse_long("-50 plus garbage",10,-100,100,&i,NULL)); - tt_int_op(0,==, i); - tt_int_op(10L,==, tor_parse_long("10m",10,0,100,&i,&cp)); - tt_int_op(1,==, i); - tt_str_op(cp,==, "m"); - tt_int_op(-50L,==, tor_parse_long("-50 plus garbage",10,-100,100,&i,&cp)); - tt_int_op(1,==, i); - tt_str_op(cp,==, " plus garbage"); + tt_int_op(0L,OP_EQ, tor_parse_long("10m",10,0,100,&i,NULL)); + tt_int_op(0,OP_EQ, i); + tt_int_op(0L,OP_EQ, tor_parse_long("-50 plus garbage",10,-100,100,&i,NULL)); + tt_int_op(0,OP_EQ, i); + tt_int_op(10L,OP_EQ, tor_parse_long("10m",10,0,100,&i,&cp)); + tt_int_op(1,OP_EQ, i); + tt_str_op(cp,OP_EQ, "m"); + tt_int_op(-50L,OP_EQ, tor_parse_long("-50 plus garbage",10,-100,100,&i,&cp)); + tt_int_op(1,OP_EQ, i); + tt_str_op(cp,OP_EQ, " plus garbage"); /* Out of bounds */ - tt_int_op(0L,==, tor_parse_long("10",10,50,100,&i,NULL)); - tt_int_op(0,==, i); - tt_int_op(0L,==, tor_parse_long("-50",10,0,100,&i,NULL)); - tt_int_op(0,==, i); + tt_int_op(0L,OP_EQ, tor_parse_long("10",10,50,100,&i,NULL)); + tt_int_op(0,OP_EQ, i); + tt_int_op(0L,OP_EQ, tor_parse_long("-50",10,0,100,&i,NULL)); + tt_int_op(0,OP_EQ, i); /* Base different than 10 */ - tt_int_op(2L,==, tor_parse_long("10",2,0,100,NULL,NULL)); - tt_int_op(0L,==, tor_parse_long("2",2,0,100,NULL,NULL)); - tt_int_op(0L,==, tor_parse_long("10",-2,0,100,NULL,NULL)); - tt_int_op(68284L,==, tor_parse_long("10abc",16,0,70000,NULL,NULL)); - tt_int_op(68284L,==, tor_parse_long("10ABC",16,0,70000,NULL,NULL)); - tt_int_op(0,==, tor_parse_long("10ABC",-1,0,70000,&i,NULL)); - tt_int_op(i,==, 0); + tt_int_op(2L,OP_EQ, tor_parse_long("10",2,0,100,NULL,NULL)); + tt_int_op(0L,OP_EQ, tor_parse_long("2",2,0,100,NULL,NULL)); + tt_int_op(0L,OP_EQ, tor_parse_long("10",-2,0,100,NULL,NULL)); + tt_int_op(68284L,OP_EQ, tor_parse_long("10abc",16,0,70000,NULL,NULL)); + tt_int_op(68284L,OP_EQ, tor_parse_long("10ABC",16,0,70000,NULL,NULL)); + tt_int_op(0,OP_EQ, tor_parse_long("10ABC",-1,0,70000,&i,NULL)); + tt_int_op(i,OP_EQ, 0);

/* Test parse_ulong */ - tt_int_op(0UL,==, tor_parse_ulong("",10,0,100,NULL,NULL)); - tt_int_op(0UL,==, tor_parse_ulong("0",10,0,100,NULL,NULL)); - tt_int_op(10UL,==, tor_parse_ulong("10",10,0,100,NULL,NULL)); - tt_int_op(0UL,==, tor_parse_ulong("10",10,50,100,NULL,NULL)); - tt_int_op(10UL,==, tor_parse_ulong("10",10,0,10,NULL,NULL)); - tt_int_op(10UL,==, tor_parse_ulong("10",10,10,100,NULL,NULL)); - tt_int_op(0UL,==, tor_parse_ulong("8",8,0,100,NULL,NULL)); - tt_int_op(50UL,==, tor_parse_ulong("50",10,50,100,NULL,NULL)); - tt_int_op(0UL,==, tor_parse_ulong("-50",10,-100,100,NULL,NULL)); - tt_int_op(0UL,==, tor_parse_ulong("50",-1,50,100,&i,NULL)); - tt_int_op(0,==, i); + tt_int_op(0UL,OP_EQ, tor_parse_ulong("",10,0,100,NULL,NULL)); + tt_int_op(0UL,OP_EQ, tor_parse_ulong("0",10,0,100,NULL,NULL)); + tt_int_op(10UL,OP_EQ, tor_parse_ulong("10",10,0,100,NULL,NULL)); + tt_int_op(0UL,OP_EQ, tor_parse_ulong("10",10,50,100,NULL,NULL)); + tt_int_op(10UL,OP_EQ, tor_parse_ulong("10",10,0,10,NULL,NULL)); + tt_int_op(10UL,OP_EQ, tor_parse_ulong("10",10,10,100,NULL,NULL)); + tt_int_op(0UL,OP_EQ, tor_parse_ulong("8",8,0,100,NULL,NULL)); + tt_int_op(50UL,OP_EQ, tor_parse_ulong("50",10,50,100,NULL,NULL)); + tt_int_op(0UL,OP_EQ, tor_parse_ulong("-50",10,-100,100,NULL,NULL)); + tt_int_op(0UL,OP_EQ, tor_parse_ulong("50",-1,50,100,&i,NULL)); + tt_int_op(0,OP_EQ, i);

/* Test parse_uint64 */ tt_assert(U64_LITERAL(10) == tor_parse_uint64("10 x",10,0,100, &i, &cp)); - tt_int_op(1,==, i); - tt_str_op(cp,==, " x"); + tt_int_op(1,OP_EQ, i); + tt_str_op(cp,OP_EQ, " x"); tt_assert(U64_LITERAL(12345678901) == tor_parse_uint64("12345678901",10,0,UINT64_MAX, &i, &cp)); - tt_int_op(1,==, i); - tt_str_op(cp,==, ""); + tt_int_op(1,OP_EQ, i); + tt_str_op(cp,OP_EQ, ""); tt_assert(U64_LITERAL(0) == tor_parse_uint64("12345678901",10,500,INT32_MAX, &i, &cp)); - tt_int_op(0,==, i); + tt_int_op(0,OP_EQ, i); tt_assert(U64_LITERAL(0) == tor_parse_uint64("123",-1,0,INT32_MAX, &i, &cp)); - tt_int_op(0,==, i); + tt_int_op(0,OP_EQ, i);

{ /* Test parse_double */ double d = tor_parse_double("10", 0, UINT64_MAX,&i,NULL); - tt_int_op(1,==, i); + tt_int_op(1,OP_EQ, i); tt_assert(DBL_TO_U64(d) == 10); d = tor_parse_double("0", 0, UINT64_MAX,&i,NULL); - tt_int_op(1,==, i); + tt_int_op(1,OP_EQ, i); tt_assert(DBL_TO_U64(d) == 0); d = tor_parse_double(" ", 0, UINT64_MAX,&i,NULL); - tt_int_op(0,==, i); + tt_int_op(0,OP_EQ, i); d = tor_parse_double(".0a", 0, UINT64_MAX,&i,NULL); - tt_int_op(0,==, i); + tt_int_op(0,OP_EQ, i); d = tor_parse_double(".0a", 0, UINT64_MAX,&i,&cp); - tt_int_op(1,==, i); + tt_int_op(1,OP_EQ, i); d = tor_parse_double("-.0", 0, UINT64_MAX,&i,NULL); - tt_int_op(1,==, i); + tt_int_op(1,OP_EQ, i); tt_assert(DBL_TO_U64(d) == 0); d = tor_parse_double("-10", -100.0, 100.0,&i,NULL); - tt_int_op(1,==, i); - tt_int_op(-10.0,==, d); + tt_int_op(1,OP_EQ, i); + tt_int_op(-10.0,OP_EQ, d); }

{ /* Test tor_parse_* where we overflow/underflow the underlying type. */ /* This string should overflow 64-bit ints. */ #define TOOBIG "100000000000000000000000000" - tt_int_op(0L,==, tor_parse_long(TOOBIG, 10, LONG_MIN, LONG_MAX, &i, NULL)); - tt_int_op(i,==, 0); - tt_int_op(0L,==, + tt_int_op(0L,OP_EQ, tor_parse_long(TOOBIG, 10, LONG_MIN, LONG_MAX, &i, NULL)); + tt_int_op(i,OP_EQ, 0); + tt_int_op(0L,OP_EQ, tor_parse_long("-"TOOBIG, 10, LONG_MIN, LONG_MAX, &i, NULL)); - tt_int_op(i,==, 0); - tt_int_op(0UL,==, tor_parse_ulong(TOOBIG, 10, 0, ULONG_MAX, &i, NULL)); - tt_int_op(i,==, 0); - tt_u64_op(U64_LITERAL(0), ==, tor_parse_uint64(TOOBIG, 10, + tt_int_op(i,OP_EQ, 0); + tt_int_op(0UL,OP_EQ, tor_parse_ulong(TOOBIG, 10, 0, ULONG_MAX, &i, NULL)); + tt_int_op(i,OP_EQ, 0); + tt_u64_op(U64_LITERAL(0), OP_EQ, tor_parse_uint64(TOOBIG, 10, 0, UINT64_MAX, &i, NULL)); - tt_int_op(i,==, 0); + tt_int_op(i,OP_EQ, 0); }

/* Test snprintf */ /* Returning -1 when there's not enough room in the output buffer */ - tt_int_op(-1,==, tor_snprintf(buf, 0, "Foo")); - tt_int_op(-1,==, tor_snprintf(buf, 2, "Foo")); - tt_int_op(-1,==, tor_snprintf(buf, 3, "Foo")); - tt_int_op(-1,!=, tor_snprintf(buf, 4, "Foo")); + tt_int_op(-1,OP_EQ, tor_snprintf(buf, 0, "Foo")); + tt_int_op(-1,OP_EQ, tor_snprintf(buf, 2, "Foo")); + tt_int_op(-1,OP_EQ, tor_snprintf(buf, 3, "Foo")); + tt_int_op(-1,OP_NE, tor_snprintf(buf, 4, "Foo")); /* Always NUL-terminate the output */ tor_snprintf(buf, 5, "abcdef"); - tt_int_op(0,==, buf[4]); + tt_int_op(0,OP_EQ, buf[4]); tor_snprintf(buf, 10, "abcdef"); - tt_int_op(0,==, buf[6]); + tt_int_op(0,OP_EQ, buf[6]); /* uint64 */ tor_snprintf(buf, sizeof(buf), "x!"U64_FORMAT"!x", U64_PRINTF_ARG(U64_LITERAL(12345678901))); - tt_str_op("x!12345678901!x",==, buf); + tt_str_op("x!12345678901!x",OP_EQ, buf);

/* Test str{,case}cmpstart */ tt_assert(strcmpstart("abcdef", "abcdef")==0); @@ -1450,31 +1450,31 @@ test_util_strmisc(void *arg)

/* Test 'escaped' */ tt_assert(NULL == escaped(NULL)); - tt_str_op("""",==, escaped("")); - tt_str_op(""abcd"",==, escaped("abcd")); - tt_str_op(""\\ \n\r\t\"\'"",==, escaped("\ \n\r\t"'")); - tt_str_op(""unnecessary \'backslashes\'"",==, + tt_str_op("""",OP_EQ, escaped("")); + tt_str_op(""abcd"",OP_EQ, escaped("abcd")); + tt_str_op(""\\ \n\r\t\"\'"",OP_EQ, escaped("\ \n\r\t"'")); + tt_str_op(""unnecessary \'backslashes\'"",OP_EQ, escaped("unnecessary 'backslashes'")); /* Non-printable characters appear as octal */ - tt_str_op(""z\001abc\277d"",==, escaped("z\001abc\277d")); - tt_str_op(""z\336\255 ;foo"",==, escaped("z\xde\xad\x20;foo")); + tt_str_op(""z\001abc\277d"",OP_EQ, escaped("z\001abc\277d")); + tt_str_op(""z\336\255 ;foo"",OP_EQ, escaped("z\xde\xad\x20;foo"));

/* Test strndup and memdup */ { const char *s = "abcdefghijklmnopqrstuvwxyz"; cp_tmp = tor_strndup(s, 30); - tt_str_op(cp_tmp,==, s); /* same string, */ - tt_ptr_op(cp_tmp,!=,s); /* but different pointers. */ + tt_str_op(cp_tmp,OP_EQ, s); /* same string, */ + tt_ptr_op(cp_tmp,OP_NE,s); /* but different pointers. */ tor_free(cp_tmp);

cp_tmp = tor_strndup(s, 5); - tt_str_op(cp_tmp,==, "abcde"); + tt_str_op(cp_tmp,OP_EQ, "abcde"); tor_free(cp_tmp);

s = "a\0b\0c\0d\0e\0"; cp_tmp = tor_memdup(s,10); - tt_mem_op(cp_tmp,==, s, 10); /* same ram, */ - tt_ptr_op(cp_tmp,!=,s); /* but different pointers. */ + tt_mem_op(cp_tmp,OP_EQ, s, 10); /* same ram, */ + tt_ptr_op(cp_tmp,OP_NE,s); /* but different pointers. */ tor_free(cp_tmp); }

@@ -1484,9 +1484,9 @@ test_util_strmisc(void *arg) cp_tmp[3] = 'D'; tt_assert(!tor_strisnonupper(cp_tmp)); tor_strupper(cp_tmp); - tt_str_op(cp_tmp,==, "ABCDEF"); + tt_str_op(cp_tmp,OP_EQ, "ABCDEF"); tor_strlower(cp_tmp); - tt_str_op(cp_tmp,==, "abcdef"); + tt_str_op(cp_tmp,OP_EQ, "abcdef"); tt_assert(tor_strisnonupper(cp_tmp)); tt_assert(tor_strisprint(cp_tmp)); cp_tmp[3] = 3; @@ -1497,18 +1497,18 @@ test_util_strmisc(void *arg) { const char *haystack = "abcde"; tt_assert(!tor_memmem(haystack, 5, "ef", 2)); - tt_ptr_op(tor_memmem(haystack, 5, "cd", 2),==, haystack + 2); - tt_ptr_op(tor_memmem(haystack, 5, "cde", 3),==, haystack + 2); + tt_ptr_op(tor_memmem(haystack, 5, "cd", 2),OP_EQ, haystack + 2); + tt_ptr_op(tor_memmem(haystack, 5, "cde", 3),OP_EQ, haystack + 2); tt_assert(!tor_memmem(haystack, 4, "cde", 3)); haystack = "ababcad"; - tt_ptr_op(tor_memmem(haystack, 7, "abc", 3),==, haystack + 2); - tt_ptr_op(tor_memmem(haystack, 7, "ad", 2),==, haystack + 5); - tt_ptr_op(tor_memmem(haystack, 7, "cad", 3),==, haystack + 4); + tt_ptr_op(tor_memmem(haystack, 7, "abc", 3),OP_EQ, haystack + 2); + tt_ptr_op(tor_memmem(haystack, 7, "ad", 2),OP_EQ, haystack + 5); + tt_ptr_op(tor_memmem(haystack, 7, "cad", 3),OP_EQ, haystack + 4); tt_assert(!tor_memmem(haystack, 7, "dadad", 5)); tt_assert(!tor_memmem(haystack, 7, "abcdefghij", 10)); /* memstr */ - tt_ptr_op(tor_memstr(haystack, 7, "abc"),==, haystack + 2); - tt_ptr_op(tor_memstr(haystack, 7, "cad"),==, haystack + 4); + tt_ptr_op(tor_memstr(haystack, 7, "abc"),OP_EQ, haystack + 2); + tt_ptr_op(tor_memstr(haystack, 7, "cad"),OP_EQ, haystack + 4); tt_assert(!tor_memstr(haystack, 6, "cad")); tt_assert(!tor_memstr(haystack, 7, "cadd")); tt_assert(!tor_memstr(haystack, 7, "fe")); @@ -1521,42 +1521,42 @@ test_util_strmisc(void *arg) size_t i; for (i = 0; i < sizeof(binary_data); ++i) binary_data[i] = i; - tt_str_op(hex_str(binary_data, 0),==, ""); - tt_str_op(hex_str(binary_data, 1),==, "00"); - tt_str_op(hex_str(binary_data, 17),==, + tt_str_op(hex_str(binary_data, 0),OP_EQ, ""); + tt_str_op(hex_str(binary_data, 1),OP_EQ, "00"); + tt_str_op(hex_str(binary_data, 17),OP_EQ, "000102030405060708090A0B0C0D0E0F10"); - tt_str_op(hex_str(binary_data, 32),==, + tt_str_op(hex_str(binary_data, 32),OP_EQ, "000102030405060708090A0B0C0D0E0F" "101112131415161718191A1B1C1D1E1F"); - tt_str_op(hex_str(binary_data, 34),==, + tt_str_op(hex_str(binary_data, 34),OP_EQ, "000102030405060708090A0B0C0D0E0F" "101112131415161718191A1B1C1D1E1F"); /* Repeat these tests for shorter strings after longer strings have been tried, to make sure we're correctly terminating strings */ - tt_str_op(hex_str(binary_data, 1),==, "00"); - tt_str_op(hex_str(binary_data, 0),==, ""); + tt_str_op(hex_str(binary_data, 1),OP_EQ, "00"); + tt_str_op(hex_str(binary_data, 0),OP_EQ, ""); }

/* Test strcmp_opt */ - tt_int_op(strcmp_opt("", "foo"), <, 0); - tt_int_op(strcmp_opt("", ""), ==, 0); - tt_int_op(strcmp_opt("foo", ""), >, 0); + tt_int_op(strcmp_opt("", "foo"), OP_LT, 0); + tt_int_op(strcmp_opt("", ""), OP_EQ, 0); + tt_int_op(strcmp_opt("foo", ""), OP_GT, 0);

- tt_int_op(strcmp_opt(NULL, ""), <, 0); - tt_int_op(strcmp_opt(NULL, NULL), ==, 0); - tt_int_op(strcmp_opt("", NULL), >, 0); + tt_int_op(strcmp_opt(NULL, ""), OP_LT, 0); + tt_int_op(strcmp_opt(NULL, NULL), OP_EQ, 0); + tt_int_op(strcmp_opt("", NULL), OP_GT, 0);

- tt_int_op(strcmp_opt(NULL, "foo"), <, 0); - tt_int_op(strcmp_opt("foo", NULL), >, 0); + tt_int_op(strcmp_opt(NULL, "foo"), OP_LT, 0); + tt_int_op(strcmp_opt("foo", NULL), OP_GT, 0);

/* Test strcmp_len */ - tt_int_op(strcmp_len("foo", "bar", 3), >, 0); - tt_int_op(strcmp_len("foo", "bar", 2), <, 0); /* First len, then lexical */ - tt_int_op(strcmp_len("foo2", "foo1", 4), >, 0); - tt_int_op(strcmp_len("foo2", "foo1", 3), <, 0); /* Really stop at len */ - tt_int_op(strcmp_len("foo2", "foo", 3), ==, 0); /* Really stop at len */ - tt_int_op(strcmp_len("blah", "", 4), >, 0); - tt_int_op(strcmp_len("blah", "", 0), ==, 0); + tt_int_op(strcmp_len("foo", "bar", 3), OP_GT, 0); + tt_int_op(strcmp_len("foo", "bar", 2), OP_LT, 0); /* First len, then lexical */ + tt_int_op(strcmp_len("foo2", "foo1", 4), OP_GT, 0); + tt_int_op(strcmp_len("foo2", "foo1", 3), OP_LT, 0); /* Really stop at len */ + tt_int_op(strcmp_len("foo2", "foo", 3), OP_EQ, 0); /* Really stop at len */ + tt_int_op(strcmp_len("blah", "", 4), OP_GT, 0); + tt_int_op(strcmp_len("blah", "", 0), OP_EQ, 0);

done: tor_free(cp_tmp); @@ -1567,34 +1567,34 @@ test_util_pow2(void *arg) { /* Test tor_log2(). */ (void)arg; - tt_int_op(tor_log2(64),==, 6); - tt_int_op(tor_log2(65),==, 6); - tt_int_op(tor_log2(63),==, 5); - tt_int_op(tor_log2(0),==, 0);/* incorrect mathematically, but as specified */ - tt_int_op(tor_log2(1),==, 0); - tt_int_op(tor_log2(2),==, 1); - tt_int_op(tor_log2(3),==, 1); - tt_int_op(tor_log2(4),==, 2); - tt_int_op(tor_log2(5),==, 2); - tt_int_op(tor_log2(U64_LITERAL(40000000000000000)),==, 55); - tt_int_op(tor_log2(UINT64_MAX),==, 63); + tt_int_op(tor_log2(64),OP_EQ, 6); + tt_int_op(tor_log2(65),OP_EQ, 6); + tt_int_op(tor_log2(63),OP_EQ, 5); + tt_int_op(tor_log2(0),OP_EQ, 0);/* incorrect mathematically, but as specified */ + tt_int_op(tor_log2(1),OP_EQ, 0); + tt_int_op(tor_log2(2),OP_EQ, 1); + tt_int_op(tor_log2(3),OP_EQ, 1); + tt_int_op(tor_log2(4),OP_EQ, 2); + tt_int_op(tor_log2(5),OP_EQ, 2); + tt_int_op(tor_log2(U64_LITERAL(40000000000000000)),OP_EQ, 55); + tt_int_op(tor_log2(UINT64_MAX),OP_EQ, 63);

/* Test round_to_power_of_2 */ - tt_u64_op(round_to_power_of_2(120), ==, 128); - tt_u64_op(round_to_power_of_2(128), ==, 128); - tt_u64_op(round_to_power_of_2(130), ==, 128); - tt_u64_op(round_to_power_of_2(U64_LITERAL(40000000000000000)), ==, + tt_u64_op(round_to_power_of_2(120), OP_EQ, 128); + tt_u64_op(round_to_power_of_2(128), OP_EQ, 128); + tt_u64_op(round_to_power_of_2(130), OP_EQ, 128); + tt_u64_op(round_to_power_of_2(U64_LITERAL(40000000000000000)), OP_EQ, U64_LITERAL(1)<<55); - tt_u64_op(round_to_power_of_2(U64_LITERAL(0xffffffffffffffff)), ==, + tt_u64_op(round_to_power_of_2(U64_LITERAL(0xffffffffffffffff)), OP_EQ, U64_LITERAL(1)<<63); - tt_u64_op(round_to_power_of_2(0), ==, 1); - tt_u64_op(round_to_power_of_2(1), ==, 1); - tt_u64_op(round_to_power_of_2(2), ==, 2); - tt_u64_op(round_to_power_of_2(3), ==, 2); - tt_u64_op(round_to_power_of_2(4), ==, 4); - tt_u64_op(round_to_power_of_2(5), ==, 4); - tt_u64_op(round_to_power_of_2(6), ==, 4); - tt_u64_op(round_to_power_of_2(7), ==, 8); + tt_u64_op(round_to_power_of_2(0), OP_EQ, 1); + tt_u64_op(round_to_power_of_2(1), OP_EQ, 1); + tt_u64_op(round_to_power_of_2(2), OP_EQ, 2); + tt_u64_op(round_to_power_of_2(3), OP_EQ, 2); + tt_u64_op(round_to_power_of_2(4), OP_EQ, 4); + tt_u64_op(round_to_power_of_2(5), OP_EQ, 4); + tt_u64_op(round_to_power_of_2(6), OP_EQ, 4); + tt_u64_op(round_to_power_of_2(7), OP_EQ, 8);

done: ; @@ -1758,8 +1758,8 @@ test_util_gzip(void *arg) tt_assert(!tor_gzip_uncompress(&buf3, &len2, buf2, len1, GZIP_METHOD, 1, LOG_INFO)); tt_assert(buf3); - tt_int_op(strlen(buf1) + 1,==, len2); - tt_str_op(buf1,==, buf3); + tt_int_op(strlen(buf1) + 1,OP_EQ, len2); + tt_str_op(buf1,OP_EQ, buf3);

tor_free(buf2); tor_free(buf3); @@ -1773,8 +1773,8 @@ test_util_gzip(void *arg) tt_assert(!tor_gzip_uncompress(&buf3, &len2, buf2, len1, ZLIB_METHOD, 1, LOG_INFO)); tt_assert(buf3); - tt_int_op(strlen(buf1) + 1,==, len2); - tt_str_op(buf1,==, buf3); + tt_int_op(strlen(buf1) + 1,OP_EQ, len2); + tt_str_op(buf1,OP_EQ, buf3);

/* Check whether we can uncompress concatenated, compressed strings. */ tor_free(buf3); @@ -1782,8 +1782,8 @@ test_util_gzip(void *arg) memcpy(buf2+len1, buf2, len1); tt_assert(!tor_gzip_uncompress(&buf3, &len2, buf2, len1*2, ZLIB_METHOD, 1, LOG_INFO)); - tt_int_op((strlen(buf1)+1)*2,==, len2); - tt_mem_op(buf3,==, + tt_int_op((strlen(buf1)+1)*2,OP_EQ, len2); + tt_mem_op(buf3,OP_EQ, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAAAAAAAAAAAAAAAAZ\0" "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAAAAAAAAAAAAAAAAZ\0", (strlen(buf1)+1)*2); @@ -1823,20 +1823,20 @@ test_util_gzip(void *arg) len2 = 21; tt_assert(tor_zlib_process(state, &cp1, &len1, &ccp2, &len2, 0) == TOR_ZLIB_OK); - tt_int_op(0,==, len2); /* Make sure we compressed it all. */ + tt_int_op(0,OP_EQ, len2); /* Make sure we compressed it all. */ tt_assert(cp1 > buf1);

len2 = 0; cp2 = cp1; tt_assert(tor_zlib_process(state, &cp1, &len1, &ccp2, &len2, 1) == TOR_ZLIB_DONE); - tt_int_op(0,==, len2); + tt_int_op(0,OP_EQ, len2); tt_assert(cp1 > cp2); /* Make sure we really added something. */

tt_assert(!tor_gzip_uncompress(&buf3, &len2, buf1, 1024-len1, ZLIB_METHOD, 1, LOG_WARN)); - tt_str_op(buf3,==,"ABCDEFGHIJABCDEFGHIJ"); /*Make sure it compressed right.*/ - tt_int_op(21,==, len2); + tt_str_op(buf3,OP_EQ,"ABCDEFGHIJABCDEFGHIJ"); /*Make sure it compressed right.*/ + tt_int_op(21,OP_EQ, len2);

done: if (state) @@ -1867,25 +1867,25 @@ test_util_mmap(void *arg)

mapping = tor_mmap_file(fname1); tt_assert(mapping); - tt_int_op(mapping->size,==, strlen("Short file.")); - tt_str_op(mapping->data,==, "Short file."); + tt_int_op(mapping->size,OP_EQ, strlen("Short file.")); + tt_str_op(mapping->data,OP_EQ, "Short file."); #ifdef _WIN32 - tt_int_op(0, ==, tor_munmap_file(mapping)); + tt_int_op(0, OP_EQ, tor_munmap_file(mapping)); mapping = NULL; tt_assert(unlink(fname1) == 0); #else /* make sure we can unlink. */ tt_assert(unlink(fname1) == 0); - tt_str_op(mapping->data,==, "Short file."); - tt_int_op(0, ==, tor_munmap_file(mapping)); + tt_str_op(mapping->data,OP_EQ, "Short file."); + tt_int_op(0, OP_EQ, tor_munmap_file(mapping)); mapping = NULL; #endif

/* Now a zero-length file. */ write_str_to_file(fname1, "", 1); mapping = tor_mmap_file(fname1); - tt_ptr_op(mapping,==, NULL); - tt_int_op(ERANGE,==, errno); + tt_ptr_op(mapping,OP_EQ, NULL); + tt_int_op(ERANGE,OP_EQ, errno); unlink(fname1);

/* Make sure that we fail to map a no-longer-existent file. */ @@ -1896,18 +1896,18 @@ test_util_mmap(void *arg) write_bytes_to_file(fname2, buf, buflen, 1); mapping = tor_mmap_file(fname2); tt_assert(mapping); - tt_int_op(mapping->size,==, buflen); - tt_mem_op(mapping->data,==, buf, buflen); - tt_int_op(0, ==, tor_munmap_file(mapping)); + tt_int_op(mapping->size,OP_EQ, buflen); + tt_mem_op(mapping->data,OP_EQ, buf, buflen); + tt_int_op(0, OP_EQ, tor_munmap_file(mapping)); mapping = NULL;

/* Now try a big aligned file. */ write_bytes_to_file(fname3, buf, 16384, 1); mapping = tor_mmap_file(fname3); tt_assert(mapping); - tt_int_op(mapping->size,==, 16384); - tt_mem_op(mapping->data,==, buf, 16384); - tt_int_op(0, ==, tor_munmap_file(mapping)); + tt_int_op(mapping->size,OP_EQ, 16384); + tt_mem_op(mapping->data,OP_EQ, buf, 16384); + tt_int_op(0, OP_EQ, tor_munmap_file(mapping)); mapping = NULL;

done: @@ -1934,9 +1934,9 @@ test_util_control_formats(void *arg)

(void)arg; sz = read_escaped_data(inp, strlen(inp), &out); - tt_str_op(out,==, + tt_str_op(out,OP_EQ, ".This is a test\nof the emergency \n.system.\n\rZ.\n"); - tt_int_op(sz,==, strlen(out)); + tt_int_op(sz,OP_EQ, strlen(out));

done: tor_free(out); @@ -1968,334 +1968,334 @@ test_util_sscanf(void *arg)

/* Simple tests (malformed patterns, literal matching, ...) */ (void)arg; - tt_int_op(-1,==, tor_sscanf("123", "%i", &r)); /* %i is not supported */ - tt_int_op(-1,==, + tt_int_op(-1,OP_EQ, tor_sscanf("123", "%i", &r)); /* %i is not supported */ + tt_int_op(-1,OP_EQ, tor_sscanf("wrong", "%5c", s1)); /* %c cannot have a number. */ - tt_int_op(-1,==, tor_sscanf("hello", "%s", s1)); /* %s needs a number. */ - tt_int_op(-1,==, tor_sscanf("prettylongstring", "%999999s", s1)); + tt_int_op(-1,OP_EQ, tor_sscanf("hello", "%s", s1)); /* %s needs a number. */ + tt_int_op(-1,OP_EQ, tor_sscanf("prettylongstring", "%999999s", s1)); #if 0 /* GCC thinks these two are illegal. */ test_eq(-1, tor_sscanf("prettylongstring", "%0s", s1)); test_eq(0, tor_sscanf("prettylongstring", "%10s", NULL)); #endif /* No '%'-strings: always "success" */ - tt_int_op(0,==, tor_sscanf("hello world", "hello world")); - tt_int_op(0,==, tor_sscanf("hello world", "good bye")); + tt_int_op(0,OP_EQ, tor_sscanf("hello world", "hello world")); + tt_int_op(0,OP_EQ, tor_sscanf("hello world", "good bye")); /* Excess data */ - tt_int_op(0,==, + tt_int_op(0,OP_EQ, tor_sscanf("hello 3", "%u", &u1)); /* have to match the start */ - tt_int_op(0,==, tor_sscanf(" 3 hello", "%u", &u1)); - tt_int_op(0,==, + tt_int_op(0,OP_EQ, tor_sscanf(" 3 hello", "%u", &u1)); + tt_int_op(0,OP_EQ, tor_sscanf(" 3 hello", "%2u", &u1)); /* not even in this case */ - tt_int_op(1,==, + tt_int_op(1,OP_EQ, tor_sscanf("3 hello", "%u", &u1)); /* but trailing is alright */

/* Numbers (ie. %u) */ - tt_int_op(0,==, + tt_int_op(0,OP_EQ, tor_sscanf("hello world 3", "hello worlb %u", &u1)); /* d vs b */ - tt_int_op(1,==, tor_sscanf("12345", "%u", &u1)); - tt_int_op(12345u,==, u1); - tt_int_op(1,==, tor_sscanf("12346 ", "%u", &u1)); - tt_int_op(12346u,==, u1); - tt_int_op(0,==, tor_sscanf(" 12347", "%u", &u1)); - tt_int_op(1,==, tor_sscanf(" 12348", " %u", &u1)); - tt_int_op(12348u,==, u1); - tt_int_op(1,==, tor_sscanf("0", "%u", &u1)); - tt_int_op(0u,==, u1); - tt_int_op(1,==, tor_sscanf("0000", "%u", &u2)); - tt_int_op(0u,==, u2); - tt_int_op(0,==, tor_sscanf("", "%u", &u1)); /* absent number */ - tt_int_op(0,==, tor_sscanf("A", "%u", &u1)); /* bogus number */ - tt_int_op(0,==, tor_sscanf("-1", "%u", &u1)); /* negative number */ + tt_int_op(1,OP_EQ, tor_sscanf("12345", "%u", &u1)); + tt_int_op(12345u,OP_EQ, u1); + tt_int_op(1,OP_EQ, tor_sscanf("12346 ", "%u", &u1)); + tt_int_op(12346u,OP_EQ, u1); + tt_int_op(0,OP_EQ, tor_sscanf(" 12347", "%u", &u1)); + tt_int_op(1,OP_EQ, tor_sscanf(" 12348", " %u", &u1)); + tt_int_op(12348u,OP_EQ, u1); + tt_int_op(1,OP_EQ, tor_sscanf("0", "%u", &u1)); + tt_int_op(0u,OP_EQ, u1); + tt_int_op(1,OP_EQ, tor_sscanf("0000", "%u", &u2)); + tt_int_op(0u,OP_EQ, u2); + tt_int_op(0,OP_EQ, tor_sscanf("", "%u", &u1)); /* absent number */ + tt_int_op(0,OP_EQ, tor_sscanf("A", "%u", &u1)); /* bogus number */ + tt_int_op(0,OP_EQ, tor_sscanf("-1", "%u", &u1)); /* negative number */

/* Numbers with size (eg. %2u) */ - tt_int_op(0,==, tor_sscanf("-1", "%2u", &u1)); - tt_int_op(2,==, tor_sscanf("123456", "%2u%u", &u1, &u2)); - tt_int_op(12u,==, u1); - tt_int_op(3456u,==, u2); - tt_int_op(1,==, tor_sscanf("123456", "%8u", &u1)); - tt_int_op(123456u,==, u1); - tt_int_op(1,==, tor_sscanf("123457 ", "%8u", &u1)); - tt_int_op(123457u,==, u1); - tt_int_op(0,==, tor_sscanf(" 123456", "%8u", &u1)); - tt_int_op(3,==, tor_sscanf("!12:3:456", "!%2u:%2u:%3u", &u1, &u2, &u3)); - tt_int_op(12u,==, u1); - tt_int_op(3u,==, u2); - tt_int_op(456u,==, u3); - tt_int_op(3,==, + tt_int_op(0,OP_EQ, tor_sscanf("-1", "%2u", &u1)); + tt_int_op(2,OP_EQ, tor_sscanf("123456", "%2u%u", &u1, &u2)); + tt_int_op(12u,OP_EQ, u1); + tt_int_op(3456u,OP_EQ, u2); + tt_int_op(1,OP_EQ, tor_sscanf("123456", "%8u", &u1)); + tt_int_op(123456u,OP_EQ, u1); + tt_int_op(1,OP_EQ, tor_sscanf("123457 ", "%8u", &u1)); + tt_int_op(123457u,OP_EQ, u1); + tt_int_op(0,OP_EQ, tor_sscanf(" 123456", "%8u", &u1)); + tt_int_op(3,OP_EQ, tor_sscanf("!12:3:456", "!%2u:%2u:%3u", &u1, &u2, &u3)); + tt_int_op(12u,OP_EQ, u1); + tt_int_op(3u,OP_EQ, u2); + tt_int_op(456u,OP_EQ, u3); + tt_int_op(3,OP_EQ, tor_sscanf("67:8:099", "%2u:%2u:%3u", &u1, &u2, &u3)); /* 0s */ - tt_int_op(67u,==, u1); - tt_int_op(8u,==, u2); - tt_int_op(99u,==, u3); + tt_int_op(67u,OP_EQ, u1); + tt_int_op(8u,OP_EQ, u2); + tt_int_op(99u,OP_EQ, u3); /* %u does not match space.*/ - tt_int_op(2,==, tor_sscanf("12:3: 45", "%2u:%2u:%3u", &u1, &u2, &u3)); - tt_int_op(12u,==, u1); - tt_int_op(3u,==, u2); + tt_int_op(2,OP_EQ, tor_sscanf("12:3: 45", "%2u:%2u:%3u", &u1, &u2, &u3)); + tt_int_op(12u,OP_EQ, u1); + tt_int_op(3u,OP_EQ, u2); /* %u does not match negative numbers. */ - tt_int_op(2,==, tor_sscanf("67:8:-9", "%2u:%2u:%3u", &u1, &u2, &u3)); - tt_int_op(67u,==, u1); - tt_int_op(8u,==, u2); + tt_int_op(2,OP_EQ, tor_sscanf("67:8:-9", "%2u:%2u:%3u", &u1, &u2, &u3)); + tt_int_op(67u,OP_EQ, u1); + tt_int_op(8u,OP_EQ, u2); /* Arbitrary amounts of 0-padding are okay */ - tt_int_op(3,==, tor_sscanf("12:03:000000000000000099", "%2u:%2u:%u", + tt_int_op(3,OP_EQ, tor_sscanf("12:03:000000000000000099", "%2u:%2u:%u", &u1, &u2, &u3)); - tt_int_op(12u,==, u1); - tt_int_op(3u,==, u2); - tt_int_op(99u,==, u3); + tt_int_op(12u,OP_EQ, u1); + tt_int_op(3u,OP_EQ, u2); + tt_int_op(99u,OP_EQ, u3);

/* Hex (ie. %x) */ - tt_int_op(3,==, tor_sscanf("1234 02aBcdEf ff", "%x %x %x", &u1, &u2, &u3)); - tt_int_op(0x1234,==, u1); - tt_int_op(0x2ABCDEF,==, u2); - tt_int_op(0xFF,==, u3); + tt_int_op(3,OP_EQ, tor_sscanf("1234 02aBcdEf ff", "%x %x %x", &u1, &u2, &u3)); + tt_int_op(0x1234,OP_EQ, u1); + tt_int_op(0x2ABCDEF,OP_EQ, u2); + tt_int_op(0xFF,OP_EQ, u3); /* Width works on %x */ - tt_int_op(3,==, tor_sscanf("f00dcafe444", "%4x%4x%u", &u1, &u2, &u3)); - tt_int_op(0xf00d,==, u1); - tt_int_op(0xcafe,==, u2); - tt_int_op(444,==, u3); + tt_int_op(3,OP_EQ, tor_sscanf("f00dcafe444", "%4x%4x%u", &u1, &u2, &u3)); + tt_int_op(0xf00d,OP_EQ, u1); + tt_int_op(0xcafe,OP_EQ, u2); + tt_int_op(444,OP_EQ, u3);

/* Literal '%' (ie. '%%') */ - tt_int_op(1,==, tor_sscanf("99% fresh", "%3u%% fresh", &u1)); - tt_int_op(99,==, u1); - tt_int_op(0,==, tor_sscanf("99 fresh", "%% %3u %s", &u1, s1)); - tt_int_op(1,==, tor_sscanf("99 fresh", "%3u%% %s", &u1, s1)); - tt_int_op(2,==, tor_sscanf("99 fresh", "%3u %5s %%", &u1, s1)); - tt_int_op(99,==, u1); - tt_str_op(s1,==, "fresh"); - tt_int_op(1,==, tor_sscanf("% boo", "%% %3s", s1)); - tt_str_op("boo",==, s1); + tt_int_op(1,OP_EQ, tor_sscanf("99% fresh", "%3u%% fresh", &u1)); + tt_int_op(99,OP_EQ, u1); + tt_int_op(0,OP_EQ, tor_sscanf("99 fresh", "%% %3u %s", &u1, s1)); + tt_int_op(1,OP_EQ, tor_sscanf("99 fresh", "%3u%% %s", &u1, s1)); + tt_int_op(2,OP_EQ, tor_sscanf("99 fresh", "%3u %5s %%", &u1, s1)); + tt_int_op(99,OP_EQ, u1); + tt_str_op(s1,OP_EQ, "fresh"); + tt_int_op(1,OP_EQ, tor_sscanf("% boo", "%% %3s", s1)); + tt_str_op("boo",OP_EQ, s1);

/* Strings (ie. %s) */ - tt_int_op(2,==, tor_sscanf("hello", "%3s%7s", s1, s2)); - tt_str_op(s1,==, "hel"); - tt_str_op(s2,==, "lo"); - tt_int_op(2,==, tor_sscanf("WD40", "%2s%u", s3, &u1)); /* %s%u */ - tt_str_op(s3,==, "WD"); - tt_int_op(40,==, u1); - tt_int_op(2,==, tor_sscanf("WD40", "%3s%u", s3, &u1)); /* %s%u */ - tt_str_op(s3,==, "WD4"); - tt_int_op(0,==, u1); - tt_int_op(2,==, tor_sscanf("76trombones", "%6u%9s", &u1, s1)); /* %u%s */ - tt_int_op(76,==, u1); - tt_str_op(s1,==, "trombones"); - tt_int_op(1,==, tor_sscanf("prettylongstring", "%999s", s1)); - tt_str_op(s1,==, "prettylongstring"); + tt_int_op(2,OP_EQ, tor_sscanf("hello", "%3s%7s", s1, s2)); + tt_str_op(s1,OP_EQ, "hel"); + tt_str_op(s2,OP_EQ, "lo"); + tt_int_op(2,OP_EQ, tor_sscanf("WD40", "%2s%u", s3, &u1)); /* %s%u */ + tt_str_op(s3,OP_EQ, "WD"); + tt_int_op(40,OP_EQ, u1); + tt_int_op(2,OP_EQ, tor_sscanf("WD40", "%3s%u", s3, &u1)); /* %s%u */ + tt_str_op(s3,OP_EQ, "WD4"); + tt_int_op(0,OP_EQ, u1); + tt_int_op(2,OP_EQ, tor_sscanf("76trombones", "%6u%9s", &u1, s1)); /* %u%s */ + tt_int_op(76,OP_EQ, u1); + tt_str_op(s1,OP_EQ, "trombones"); + tt_int_op(1,OP_EQ, tor_sscanf("prettylongstring", "%999s", s1)); + tt_str_op(s1,OP_EQ, "prettylongstring"); /* %s doesn't eat spaces */ - tt_int_op(2,==, tor_sscanf("hello world", "%9s %9s", s1, s2)); - tt_str_op(s1,==, "hello"); - tt_str_op(s2,==, "world"); - tt_int_op(2,==, tor_sscanf("bye world?", "%9s %9s", s1, s2)); - tt_str_op(s1,==, "bye"); - tt_str_op(s2,==, ""); - tt_int_op(3,==, + tt_int_op(2,OP_EQ, tor_sscanf("hello world", "%9s %9s", s1, s2)); + tt_str_op(s1,OP_EQ, "hello"); + tt_str_op(s2,OP_EQ, "world"); + tt_int_op(2,OP_EQ, tor_sscanf("bye world?", "%9s %9s", s1, s2)); + tt_str_op(s1,OP_EQ, "bye"); + tt_str_op(s2,OP_EQ, ""); + tt_int_op(3,OP_EQ, tor_sscanf("hi", "%9s%9s%3s", s1, s2, s3)); /* %s can be empty. */ - tt_str_op(s1,==, "hi"); - tt_str_op(s2,==, ""); - tt_str_op(s3,==, ""); + tt_str_op(s1,OP_EQ, "hi"); + tt_str_op(s2,OP_EQ, ""); + tt_str_op(s3,OP_EQ, "");

- tt_int_op(3,==, tor_sscanf("1.2.3", "%u.%u.%u%c", &u1, &u2, &u3, &ch)); - tt_int_op(4,==, + tt_int_op(3,OP_EQ, tor_sscanf("1.2.3", "%u.%u.%u%c", &u1, &u2, &u3, &ch)); + tt_int_op(4,OP_EQ, tor_sscanf("1.2.3 foobar", "%u.%u.%u%c", &u1, &u2, &u3, &ch)); - tt_int_op(' ',==, ch); + tt_int_op(' ',OP_EQ, ch);

r = tor_sscanf("12345 -67890 -1", "%d %ld %d", &int1, &lng1, &int2); - tt_int_op(r,==, 3); - tt_int_op(int1,==, 12345); - tt_int_op(lng1,==, -67890); - tt_int_op(int2,==, -1); + tt_int_op(r,OP_EQ, 3); + tt_int_op(int1,OP_EQ, 12345); + tt_int_op(lng1,OP_EQ, -67890); + tt_int_op(int2,OP_EQ, -1);

#if SIZEOF_INT == 4 /* %u */ /* UINT32_MAX should work */ - tt_int_op(1,==, tor_sscanf("4294967295", "%u", &u1)); - tt_int_op(4294967295U,==, u1); + tt_int_op(1,OP_EQ, tor_sscanf("4294967295", "%u", &u1)); + tt_int_op(4294967295U,OP_EQ, u1);

/* But UINT32_MAX + 1 shouldn't work */ - tt_int_op(0,==, tor_sscanf("4294967296", "%u", &u1)); + tt_int_op(0,OP_EQ, tor_sscanf("4294967296", "%u", &u1)); /* but parsing only 9... */ - tt_int_op(1,==, tor_sscanf("4294967296", "%9u", &u1)); - tt_int_op(429496729U,==, u1); + tt_int_op(1,OP_EQ, tor_sscanf("4294967296", "%9u", &u1)); + tt_int_op(429496729U,OP_EQ, u1);

/* %x */ /* UINT32_MAX should work */ - tt_int_op(1,==, tor_sscanf("FFFFFFFF", "%x", &u1)); - tt_int_op(0xFFFFFFFF,==, u1); + tt_int_op(1,OP_EQ, tor_sscanf("FFFFFFFF", "%x", &u1)); + tt_int_op(0xFFFFFFFF,OP_EQ, u1);

/* But UINT32_MAX + 1 shouldn't work */ - tt_int_op(0,==, tor_sscanf("100000000", "%x", &u1)); + tt_int_op(0,OP_EQ, tor_sscanf("100000000", "%x", &u1));

/* %d */ /* INT32_MIN and INT32_MAX should work */ r = tor_sscanf("-2147483648. 2147483647.", "%d. %d.", &int1, &int2); - tt_int_op(r,==, 2); - tt_int_op(int1,==, -2147483647 - 1); - tt_int_op(int2,==, 2147483647); + tt_int_op(r,OP_EQ, 2); + tt_int_op(int1,OP_EQ, -2147483647 - 1); + tt_int_op(int2,OP_EQ, 2147483647);

/* But INT32_MIN - 1 and INT32_MAX + 1 shouldn't work */ r = tor_sscanf("-2147483649.", "%d.", &int1); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0);

r = tor_sscanf("2147483648.", "%d.", &int1); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0);

/* and the first failure stops further processing */ r = tor_sscanf("-2147483648. 2147483648.", "%d. %d.", &int1, &int2); - tt_int_op(r,==, 1); + tt_int_op(r,OP_EQ, 1);

r = tor_sscanf("-2147483649. 2147483647.", "%d. %d.", &int1, &int2); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0);

r = tor_sscanf("2147483648. -2147483649.", "%d. %d.", &int1, &int2); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0); #elif SIZEOF_INT == 8 /* %u */ /* UINT64_MAX should work */ - tt_int_op(1,==, tor_sscanf("18446744073709551615", "%u", &u1)); - tt_int_op(18446744073709551615U,==, u1); + tt_int_op(1,OP_EQ, tor_sscanf("18446744073709551615", "%u", &u1)); + tt_int_op(18446744073709551615U,OP_EQ, u1);

/* But UINT64_MAX + 1 shouldn't work */ - tt_int_op(0,==, tor_sscanf("18446744073709551616", "%u", &u1)); + tt_int_op(0,OP_EQ, tor_sscanf("18446744073709551616", "%u", &u1)); /* but parsing only 19... */ - tt_int_op(1,==, tor_sscanf("18446744073709551616", "%19u", &u1)); - tt_int_op(1844674407370955161U,==, u1); + tt_int_op(1,OP_EQ, tor_sscanf("18446744073709551616", "%19u", &u1)); + tt_int_op(1844674407370955161U,OP_EQ, u1);

/* %x */ /* UINT64_MAX should work */ - tt_int_op(1,==, tor_sscanf("FFFFFFFFFFFFFFFF", "%x", &u1)); - tt_int_op(0xFFFFFFFFFFFFFFFF,==, u1); + tt_int_op(1,OP_EQ, tor_sscanf("FFFFFFFFFFFFFFFF", "%x", &u1)); + tt_int_op(0xFFFFFFFFFFFFFFFF,OP_EQ, u1);

/* But UINT64_MAX + 1 shouldn't work */ - tt_int_op(0,==, tor_sscanf("10000000000000000", "%x", &u1)); + tt_int_op(0,OP_EQ, tor_sscanf("10000000000000000", "%x", &u1));

/* %d */ /* INT64_MIN and INT64_MAX should work */ r = tor_sscanf("-9223372036854775808. 9223372036854775807.", "%d. %d.", &int1, &int2); - tt_int_op(r,==, 2); - tt_int_op(int1,==, -9223372036854775807 - 1); - tt_int_op(int2,==, 9223372036854775807); + tt_int_op(r,OP_EQ, 2); + tt_int_op(int1,OP_EQ, -9223372036854775807 - 1); + tt_int_op(int2,OP_EQ, 9223372036854775807);

/* But INT64_MIN - 1 and INT64_MAX + 1 shouldn't work */ r = tor_sscanf("-9223372036854775809.", "%d.", &int1); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0);

r = tor_sscanf("9223372036854775808.", "%d.", &int1); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0);

/* and the first failure stops further processing */ r = tor_sscanf("-9223372036854775808. 9223372036854775808.", "%d. %d.", &int1, &int2); - tt_int_op(r,==, 1); + tt_int_op(r,OP_EQ, 1);

r = tor_sscanf("-9223372036854775809. 9223372036854775807.", "%d. %d.", &int1, &int2); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0);

r = tor_sscanf("9223372036854775808. -9223372036854775809.", "%d. %d.", &int1, &int2); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0); #endif

#if SIZEOF_LONG == 4 /* %lu */ /* UINT32_MAX should work */ - tt_int_op(1,==, tor_sscanf("4294967295", "%lu", &ulng)); - tt_int_op(4294967295UL,==, ulng); + tt_int_op(1,OP_EQ, tor_sscanf("4294967295", "%lu", &ulng)); + tt_int_op(4294967295UL,OP_EQ, ulng);

/* But UINT32_MAX + 1 shouldn't work */ - tt_int_op(0,==, tor_sscanf("4294967296", "%lu", &ulng)); + tt_int_op(0,OP_EQ, tor_sscanf("4294967296", "%lu", &ulng)); /* but parsing only 9... */ - tt_int_op(1,==, tor_sscanf("4294967296", "%9lu", &ulng)); - tt_int_op(429496729UL,==, ulng); + tt_int_op(1,OP_EQ, tor_sscanf("4294967296", "%9lu", &ulng)); + tt_int_op(429496729UL,OP_EQ, ulng);

/* %lx */ /* UINT32_MAX should work */ - tt_int_op(1,==, tor_sscanf("FFFFFFFF", "%lx", &ulng)); - tt_int_op(0xFFFFFFFFUL,==, ulng); + tt_int_op(1,OP_EQ, tor_sscanf("FFFFFFFF", "%lx", &ulng)); + tt_int_op(0xFFFFFFFFUL,OP_EQ, ulng);

/* But UINT32_MAX + 1 shouldn't work */ - tt_int_op(0,==, tor_sscanf("100000000", "%lx", &ulng)); + tt_int_op(0,OP_EQ, tor_sscanf("100000000", "%lx", &ulng));

/* %ld */ /* INT32_MIN and INT32_MAX should work */ r = tor_sscanf("-2147483648. 2147483647.", "%ld. %ld.", &lng1, &lng2); - tt_int_op(r,==, 2); - tt_int_op(lng1,==, -2147483647L - 1L); - tt_int_op(lng2,==, 2147483647L); + tt_int_op(r,OP_EQ, 2); + tt_int_op(lng1,OP_EQ, -2147483647L - 1L); + tt_int_op(lng2,OP_EQ, 2147483647L);

/* But INT32_MIN - 1 and INT32_MAX + 1 shouldn't work */ r = tor_sscanf("-2147483649.", "%ld.", &lng1); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0);

r = tor_sscanf("2147483648.", "%ld.", &lng1); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0);

/* and the first failure stops further processing */ r = tor_sscanf("-2147483648. 2147483648.", "%ld. %ld.", &lng1, &lng2); - tt_int_op(r,==, 1); + tt_int_op(r,OP_EQ, 1);

r = tor_sscanf("-2147483649. 2147483647.", "%ld. %ld.", &lng1, &lng2); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0);

r = tor_sscanf("2147483648. -2147483649.", "%ld. %ld.", &lng1, &lng2); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0); #elif SIZEOF_LONG == 8 /* %lu */ /* UINT64_MAX should work */ - tt_int_op(1,==, tor_sscanf("18446744073709551615", "%lu", &ulng)); - tt_int_op(18446744073709551615UL,==, ulng); + tt_int_op(1,OP_EQ, tor_sscanf("18446744073709551615", "%lu", &ulng)); + tt_int_op(18446744073709551615UL,OP_EQ, ulng);

/* But UINT64_MAX + 1 shouldn't work */ - tt_int_op(0,==, tor_sscanf("18446744073709551616", "%lu", &ulng)); + tt_int_op(0,OP_EQ, tor_sscanf("18446744073709551616", "%lu", &ulng)); /* but parsing only 19... */ - tt_int_op(1,==, tor_sscanf("18446744073709551616", "%19lu", &ulng)); - tt_int_op(1844674407370955161UL,==, ulng); + tt_int_op(1,OP_EQ, tor_sscanf("18446744073709551616", "%19lu", &ulng)); + tt_int_op(1844674407370955161UL,OP_EQ, ulng);

/* %lx */ /* UINT64_MAX should work */ - tt_int_op(1,==, tor_sscanf("FFFFFFFFFFFFFFFF", "%lx", &ulng)); - tt_int_op(0xFFFFFFFFFFFFFFFFUL,==, ulng); + tt_int_op(1,OP_EQ, tor_sscanf("FFFFFFFFFFFFFFFF", "%lx", &ulng)); + tt_int_op(0xFFFFFFFFFFFFFFFFUL,OP_EQ, ulng);

/* But UINT64_MAX + 1 shouldn't work */ - tt_int_op(0,==, tor_sscanf("10000000000000000", "%lx", &ulng)); + tt_int_op(0,OP_EQ, tor_sscanf("10000000000000000", "%lx", &ulng));

/* %ld */ /* INT64_MIN and INT64_MAX should work */ r = tor_sscanf("-9223372036854775808. 9223372036854775807.", "%ld. %ld.", &lng1, &lng2); - tt_int_op(r,==, 2); - tt_int_op(lng1,==, -9223372036854775807L - 1L); - tt_int_op(lng2,==, 9223372036854775807L); + tt_int_op(r,OP_EQ, 2); + tt_int_op(lng1,OP_EQ, -9223372036854775807L - 1L); + tt_int_op(lng2,OP_EQ, 9223372036854775807L);

/* But INT64_MIN - 1 and INT64_MAX + 1 shouldn't work */ r = tor_sscanf("-9223372036854775809.", "%ld.", &lng1); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0);

r = tor_sscanf("9223372036854775808.", "%ld.", &lng1); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0);

/* and the first failure stops further processing */ r = tor_sscanf("-9223372036854775808. 9223372036854775808.", "%ld. %ld.", &lng1, &lng2); - tt_int_op(r,==, 1); + tt_int_op(r,OP_EQ, 1);

r = tor_sscanf("-9223372036854775809. 9223372036854775807.", "%ld. %ld.", &lng1, &lng2); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0);

r = tor_sscanf("9223372036854775808. -9223372036854775809.", "%ld. %ld.", &lng1, &lng2); - tt_int_op(r,==, 0); + tt_int_op(r,OP_EQ, 0); #endif

r = tor_sscanf("123.456 .000007 -900123123.2000787 00003.2", "%lf %lf %lf %lf", &d1,&d2,&d3,&d4); - tt_int_op(r,==, 4); + tt_int_op(r,OP_EQ, 4); test_feq(d1, 123.456); test_feq(d2, .000007); test_feq(d3, -900123123.2000787); @@ -2350,234 +2350,234 @@ test_util_format_time_interval(void *arg)

/* ignore exact spelling of "second(s)"*/ format_time_interval(dbuf, sizeof(dbuf), 0); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_, &sec, label_s); - tt_int_op(r,==, 2); - tt_ci_char_op(label_s[0],==, 's'); - tt_int_op(sec,==, 0); + tt_int_op(r,OP_EQ, 2); + tt_ci_char_op(label_s[0],OP_EQ, 's'); + tt_int_op(sec,OP_EQ, 0);

format_time_interval(dbuf, sizeof(dbuf), 1); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_, &sec, label_s); - tt_int_op(r,==, 2); - tt_ci_char_op(label_s[0],==, 's'); - tt_int_op(sec,==, 1); + tt_int_op(r,OP_EQ, 2); + tt_ci_char_op(label_s[0],OP_EQ, 's'); + tt_int_op(sec,OP_EQ, 1);

format_time_interval(dbuf, sizeof(dbuf), 10); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_, &sec, label_s); - tt_int_op(r,==, 2); - tt_ci_char_op(label_s[0],==, 's'); - tt_int_op(sec,==, 10); + tt_int_op(r,OP_EQ, 2); + tt_ci_char_op(label_s[0],OP_EQ, 's'); + tt_int_op(sec,OP_EQ, 10);

format_time_interval(dbuf, sizeof(dbuf), 59); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_, &sec, label_s); - tt_int_op(r,==, 2); - tt_ci_char_op(label_s[0],==, 's'); - tt_int_op(sec,==, 59); + tt_int_op(r,OP_EQ, 2); + tt_ci_char_op(label_s[0],OP_EQ, 's'); + tt_int_op(sec,OP_EQ, 59);

/* negative seconds are reported as their absolute value */

format_time_interval(dbuf, sizeof(dbuf), -4); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_, &sec, label_s); - tt_int_op(r,==, 2); - tt_ci_char_op(label_s[0],==, 's'); - tt_int_op(sec,==, 4); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(r,OP_EQ, 2); + tt_ci_char_op(label_s[0],OP_EQ, 's'); + tt_int_op(sec,OP_EQ, 4); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);

format_time_interval(dbuf, sizeof(dbuf), -32); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_, &sec, label_s); - tt_int_op(r,==, 2); - tt_ci_char_op(label_s[0],==, 's'); - tt_int_op(sec,==, 32); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(r,OP_EQ, 2); + tt_ci_char_op(label_s[0],OP_EQ, 's'); + tt_int_op(sec,OP_EQ, 32); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);

/* minutes: 1:00, 1:01, 1:59, 2:00, 2:01, 59:59 */

/* ignore trailing "0 second(s)", if present */ format_time_interval(dbuf, sizeof(dbuf), 60); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_, &min, label_m); - tt_int_op(r,==, 2); - tt_ci_char_op(label_m[0],==, 'm'); - tt_int_op(min,==, 1); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(r,OP_EQ, 2); + tt_ci_char_op(label_m[0],OP_EQ, 'm'); + tt_int_op(min,OP_EQ, 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);

/* ignore exact spelling of "minute(s)," and "second(s)" */ format_time_interval(dbuf, sizeof(dbuf), 60 + 1); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_, &min, label_m, &sec, label_s); - tt_int_op(r,==, 4); - tt_int_op(min,==, 1); - tt_ci_char_op(label_m[0],==, 'm'); - tt_int_op(sec,==, 1); - tt_ci_char_op(label_s[0],==, 's'); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(r,OP_EQ, 4); + tt_int_op(min,OP_EQ, 1); + tt_ci_char_op(label_m[0],OP_EQ, 'm'); + tt_int_op(sec,OP_EQ, 1); + tt_ci_char_op(label_s[0],OP_EQ, 's'); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1);

format_time_interval(dbuf, sizeof(dbuf), 60*2 - 1); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_, &min, label_m, &sec, label_s); - tt_int_op(r,==, 4); - tt_int_op(min,==, 1); - tt_ci_char_op(label_m[0],==, 'm'); - tt_int_op(sec,==, 59); - tt_ci_char_op(label_s[0],==, 's'); + tt_int_op(r,OP_EQ, 4); + tt_int_op(min,OP_EQ, 1); + tt_ci_char_op(label_m[0],OP_EQ, 'm'); + tt_int_op(sec,OP_EQ, 59); + tt_ci_char_op(label_s[0],OP_EQ, 's');

/* ignore trailing "0 second(s)", if present */ format_time_interval(dbuf, sizeof(dbuf), 60*2); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_, &min, label_m); - tt_int_op(r,==, 2); - tt_int_op(min,==, 2); - tt_ci_char_op(label_m[0],==, 'm'); + tt_int_op(r,OP_EQ, 2); + tt_int_op(min,OP_EQ, 2); + tt_ci_char_op(label_m[0],OP_EQ, 'm');

/* ignore exact spelling of "minute(s)," and "second(s)" */ format_time_interval(dbuf, sizeof(dbuf), 60*2 + 1); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_, &min, label_m, &sec, label_s); - tt_int_op(r,==, 4); - tt_int_op(min,==, 2); - tt_ci_char_op(label_m[0],==, 'm'); - tt_int_op(sec,==, 1); - tt_ci_char_op(label_s[0],==, 's'); + tt_int_op(r,OP_EQ, 4); + tt_int_op(min,OP_EQ, 2); + tt_ci_char_op(label_m[0],OP_EQ, 'm'); + tt_int_op(sec,OP_EQ, 1); + tt_ci_char_op(label_s[0],OP_EQ, 's');

format_time_interval(dbuf, sizeof(dbuf), 60*60 - 1); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_, &min, label_m, &sec, label_s); - tt_int_op(r,==, 4); - tt_int_op(min,==, 59); - tt_ci_char_op(label_m[0],==, 'm'); - tt_int_op(sec,==, 59); - tt_ci_char_op(label_s[0],==, 's'); + tt_int_op(r,OP_EQ, 4); + tt_int_op(min,OP_EQ, 59); + tt_ci_char_op(label_m[0],OP_EQ, 'm'); + tt_int_op(sec,OP_EQ, 59); + tt_ci_char_op(label_s[0],OP_EQ, 's');

/* negative minutes are reported as their absolute value */

/* ignore trailing "0 second(s)", if present */ format_time_interval(dbuf, sizeof(dbuf), -3*60); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_, &min, label_m); - tt_int_op(r,==, 2); - tt_int_op(min,==, 3); - tt_ci_char_op(label_m[0],==, 'm'); + tt_int_op(r,OP_EQ, 2); + tt_int_op(min,OP_EQ, 3); + tt_ci_char_op(label_m[0],OP_EQ, 'm');

/* ignore exact spelling of "minute(s)," and "second(s)" */ format_time_interval(dbuf, sizeof(dbuf), -96); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_, &min, label_m, &sec, label_s); - tt_int_op(r,==, 4); - tt_int_op(min,==, 1); - tt_ci_char_op(label_m[0],==, 'm'); - tt_int_op(sec,==, 36); - tt_ci_char_op(label_s[0],==, 's'); + tt_int_op(r,OP_EQ, 4); + tt_int_op(min,OP_EQ, 1); + tt_ci_char_op(label_m[0],OP_EQ, 'm'); + tt_int_op(sec,OP_EQ, 36); + tt_ci_char_op(label_s[0],OP_EQ, 's');

format_time_interval(dbuf, sizeof(dbuf), -2815); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_, &min, label_m, &sec, label_s); - tt_int_op(r,==, 4); - tt_int_op(min,==, 46); - tt_ci_char_op(label_m[0],==, 'm'); - tt_int_op(sec,==, 55); - tt_ci_char_op(label_s[0],==, 's'); + tt_int_op(r,OP_EQ, 4); + tt_int_op(min,OP_EQ, 46); + tt_ci_char_op(label_m[0],OP_EQ, 'm'); + tt_int_op(sec,OP_EQ, 55); + tt_ci_char_op(label_s[0],OP_EQ, 's');

/* hours: 1:00, 1:00:01, 1:01, 23:59, 23:59:59 */ /* always ignore trailing seconds, if present */

/* ignore trailing "0 minute(s)" etc., if present */ format_time_interval(dbuf, sizeof(dbuf), 60*60); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_, &hour, label_h); - tt_int_op(r,==, 2); - tt_int_op(hour,==, 1); - tt_ci_char_op(label_h[0],==, 'h'); + tt_int_op(r,OP_EQ, 2); + tt_int_op(hour,OP_EQ, 1); + tt_ci_char_op(label_h[0],OP_EQ, 'h');

format_time_interval(dbuf, sizeof(dbuf), 60*60 + 1); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_, &hour, label_h); - tt_int_op(r,==, 2); - tt_int_op(hour,==, 1); - tt_ci_char_op(label_h[0],==, 'h'); + tt_int_op(r,OP_EQ, 2); + tt_int_op(hour,OP_EQ, 1); + tt_ci_char_op(label_h[0],OP_EQ, 'h');

/* ignore exact spelling of "hour(s)," etc. */ format_time_interval(dbuf, sizeof(dbuf), 60*60 + 60); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_, &hour, label_h, &min, label_m); - tt_int_op(r,==, 4); - tt_int_op(hour,==, 1); - tt_ci_char_op(label_h[0],==, 'h'); - tt_int_op(min,==, 1); - tt_ci_char_op(label_m[0],==, 'm'); + tt_int_op(r,OP_EQ, 4); + tt_int_op(hour,OP_EQ, 1); + tt_ci_char_op(label_h[0],OP_EQ, 'h'); + tt_int_op(min,OP_EQ, 1); + tt_ci_char_op(label_m[0],OP_EQ, 'm');

format_time_interval(dbuf, sizeof(dbuf), 24*60*60 - 60); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_, &hour, label_h, &min, label_m); - tt_int_op(r,==, 4); - tt_int_op(hour,==, 23); - tt_ci_char_op(label_h[0],==, 'h'); - tt_int_op(min,==, 59); - tt_ci_char_op(label_m[0],==, 'm'); + tt_int_op(r,OP_EQ, 4); + tt_int_op(hour,OP_EQ, 23); + tt_ci_char_op(label_h[0],OP_EQ, 'h'); + tt_int_op(min,OP_EQ, 59); + tt_ci_char_op(label_m[0],OP_EQ, 'm');

format_time_interval(dbuf, sizeof(dbuf), 24*60*60 - 1); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_, &hour, label_h, &min, label_m); - tt_int_op(r,==, 4); - tt_int_op(hour,==, 23); - tt_ci_char_op(label_h[0],==, 'h'); - tt_int_op(min,==, 59); - tt_ci_char_op(label_m[0],==, 'm'); + tt_int_op(r,OP_EQ, 4); + tt_int_op(hour,OP_EQ, 23); + tt_ci_char_op(label_h[0],OP_EQ, 'h'); + tt_int_op(min,OP_EQ, 59); + tt_ci_char_op(label_m[0],OP_EQ, 'm');

/* negative hours are reported as their absolute value */

/* ignore exact spelling of "hour(s)," etc., if present */ format_time_interval(dbuf, sizeof(dbuf), -2*60*60); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_, &hour, label_h); - tt_int_op(r,==, 2); - tt_int_op(hour,==, 2); - tt_ci_char_op(label_h[0],==, 'h'); + tt_int_op(r,OP_EQ, 2); + tt_int_op(hour,OP_EQ, 2); + tt_ci_char_op(label_h[0],OP_EQ, 'h');

format_time_interval(dbuf, sizeof(dbuf), -75804); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_, &hour, label_h, &min, label_m); - tt_int_op(r,==, 4); - tt_int_op(hour,==, 21); - tt_ci_char_op(label_h[0],==, 'h'); - tt_int_op(min,==, 3); - tt_ci_char_op(label_m[0],==, 'm'); + tt_int_op(r,OP_EQ, 4); + tt_int_op(hour,OP_EQ, 21); + tt_ci_char_op(label_h[0],OP_EQ, 'h'); + tt_int_op(min,OP_EQ, 3); + tt_ci_char_op(label_m[0],OP_EQ, 'm');

/* days: 1:00, 1:00:00:01, 1:00:01, 1:01 */ /* always ignore trailing seconds, if present */

/* ignore trailing "0 hours(s)" etc., if present */ format_time_interval(dbuf, sizeof(dbuf), 24*60*60); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_, &day, label_d); - tt_int_op(r,==, 2); - tt_int_op(day,==, 1); - tt_ci_char_op(label_d[0],==, 'd'); + tt_int_op(r,OP_EQ, 2); + tt_int_op(day,OP_EQ, 1); + tt_ci_char_op(label_d[0],OP_EQ, 'd');

format_time_interval(dbuf, sizeof(dbuf), 24*60*60 + 1); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_, &day, label_d); - tt_int_op(r,==, 2); - tt_int_op(day,==, 1); - tt_ci_char_op(label_d[0],==, 'd'); + tt_int_op(r,OP_EQ, 2); + tt_int_op(day,OP_EQ, 1); + tt_ci_char_op(label_d[0],OP_EQ, 'd');

/* ignore exact spelling of "days(s)," etc. */ format_time_interval(dbuf, sizeof(dbuf), 24*60*60 + 60); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_ " " TL_, &day, label_d, &hour, label_h, &min, label_m); if (r == -1) { @@ -2586,68 +2586,68 @@ test_util_format_time_interval(void *arg) &day, label_d, &min, label_m); } tt_assert(r == 4 || r == 6); - tt_int_op(day,==, 1); - tt_ci_char_op(label_d[0],==, 'd'); + tt_int_op(day,OP_EQ, 1); + tt_ci_char_op(label_d[0],OP_EQ, 'd'); if (r == 6) { - tt_int_op(hour,==, 0); - tt_ci_char_op(label_h[0],==, 'h'); + tt_int_op(hour,OP_EQ, 0); + tt_ci_char_op(label_h[0],OP_EQ, 'h'); } - tt_int_op(min,==, 1); - tt_ci_char_op(label_m[0],==, 'm'); + tt_int_op(min,OP_EQ, 1); + tt_ci_char_op(label_m[0],OP_EQ, 'm');

/* ignore trailing "0 minutes(s)" etc., if present */ format_time_interval(dbuf, sizeof(dbuf), 24*60*60 + 60*60); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_, &day, label_d, &hour, label_h); - tt_int_op(r,==, 4); - tt_int_op(day,==, 1); - tt_ci_char_op(label_d[0],==, 'd'); - tt_int_op(hour,==, 1); - tt_ci_char_op(label_h[0],==, 'h'); + tt_int_op(r,OP_EQ, 4); + tt_int_op(day,OP_EQ, 1); + tt_ci_char_op(label_d[0],OP_EQ, 'd'); + tt_int_op(hour,OP_EQ, 1); + tt_ci_char_op(label_h[0],OP_EQ, 'h');

/* negative days are reported as their absolute value */

format_time_interval(dbuf, sizeof(dbuf), -21936184); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_ " " TL_, &day, label_d, &hour, label_h, &min, label_m); - tt_int_op(r,==, 6); - tt_int_op(day,==, 253); - tt_ci_char_op(label_d[0],==, 'd'); - tt_int_op(hour,==, 21); - tt_ci_char_op(label_h[0],==, 'h'); - tt_int_op(min,==, 23); - tt_ci_char_op(label_m[0],==, 'm'); + tt_int_op(r,OP_EQ, 6); + tt_int_op(day,OP_EQ, 253); + tt_ci_char_op(label_d[0],OP_EQ, 'd'); + tt_int_op(hour,OP_EQ, 21); + tt_ci_char_op(label_h[0],OP_EQ, 'h'); + tt_int_op(min,OP_EQ, 23); + tt_ci_char_op(label_m[0],OP_EQ, 'm');

/* periods > 1 year are reported in days (warn?) */

/* ignore exact spelling of "days(s)," etc., if present */ format_time_interval(dbuf, sizeof(dbuf), 758635154); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_ " " TL_, &day, label_d, &hour, label_h, &min, label_m); - tt_int_op(r,==, 6); - tt_int_op(day,==, 8780); - tt_ci_char_op(label_d[0],==, 'd'); - tt_int_op(hour,==, 11); - tt_ci_char_op(label_h[0],==, 'h'); - tt_int_op(min,==, 59); - tt_ci_char_op(label_m[0],==, 'm'); + tt_int_op(r,OP_EQ, 6); + tt_int_op(day,OP_EQ, 8780); + tt_ci_char_op(label_d[0],OP_EQ, 'd'); + tt_int_op(hour,OP_EQ, 11); + tt_ci_char_op(label_h[0],OP_EQ, 'h'); + tt_int_op(min,OP_EQ, 59); + tt_ci_char_op(label_m[0],OP_EQ, 'm');

/* negative periods > 1 year are reported in days (warn?) */

format_time_interval(dbuf, sizeof(dbuf), -1427014922); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_ " " TL_, &day, label_d, &hour, label_h, &min, label_m); - tt_int_op(r,==, 6); - tt_int_op(day,==, 16516); - tt_ci_char_op(label_d[0],==, 'd'); - tt_int_op(hour,==, 9); - tt_ci_char_op(label_h[0],==, 'h'); - tt_int_op(min,==, 2); - tt_ci_char_op(label_m[0],==, 'm'); + tt_int_op(r,OP_EQ, 6); + tt_int_op(day,OP_EQ, 16516); + tt_ci_char_op(label_d[0],OP_EQ, 'd'); + tt_int_op(hour,OP_EQ, 9); + tt_ci_char_op(label_h[0],OP_EQ, 'h'); + tt_int_op(min,OP_EQ, 2); + tt_ci_char_op(label_m[0],OP_EQ, 'm');

#if SIZEOF_LONG == 4 || SIZEOF_LONG == 8

@@ -2656,32 +2656,32 @@ test_util_format_time_interval(void *arg)

/* INT32_MAX */ format_time_interval(dbuf, sizeof(dbuf), 2147483647); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_ " " TL_, &day, label_d, &hour, label_h, &min, label_m); - tt_int_op(r,==, 6); - tt_int_op(day,==, 24855); - tt_ci_char_op(label_d[0],==, 'd'); - tt_int_op(hour,==, 3); - tt_ci_char_op(label_h[0],==, 'h'); - tt_int_op(min,==, 14); - tt_ci_char_op(label_m[0],==, 'm'); + tt_int_op(r,OP_EQ, 6); + tt_int_op(day,OP_EQ, 24855); + tt_ci_char_op(label_d[0],OP_EQ, 'd'); + tt_int_op(hour,OP_EQ, 3); + tt_ci_char_op(label_h[0],OP_EQ, 'h'); + tt_int_op(min,OP_EQ, 14); + tt_ci_char_op(label_m[0],OP_EQ, 'm'); /* and 7 seconds - ignored */

/* INT32_MIN: check that we get the absolute value of interval, * which doesn't actually fit in int32_t. * We expect INT32_MAX or INT32_MAX + 1 with 64 bit longs */ format_time_interval(dbuf, sizeof(dbuf), -2147483647L - 1L); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_ " " TL_, &day, label_d, &hour, label_h, &min, label_m); - tt_int_op(r,==, 6); - tt_int_op(day,==, 24855); - tt_ci_char_op(label_d[0],==, 'd'); - tt_int_op(hour,==, 3); - tt_ci_char_op(label_h[0],==, 'h'); - tt_int_op(min,==, 14); - tt_ci_char_op(label_m[0],==, 'm'); + tt_int_op(r,OP_EQ, 6); + tt_int_op(day,OP_EQ, 24855); + tt_ci_char_op(label_d[0],OP_EQ, 'd'); + tt_int_op(hour,OP_EQ, 3); + tt_ci_char_op(label_h[0],OP_EQ, 'h'); + tt_int_op(min,OP_EQ, 14); + tt_ci_char_op(label_m[0],OP_EQ, 'm'); /* and 7 or 8 seconds - ignored */

#endif @@ -2693,16 +2693,16 @@ test_util_format_time_interval(void *arg)

/* INT64_MAX */ format_time_interval(dbuf, sizeof(dbuf), 9223372036854775807L); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_ " " TL_, &day, label_d, &hour, label_h, &min, label_m); - tt_int_op(r,==, 6); - tt_int_op(day,==, 106751991167300L); - tt_ci_char_op(label_d[0],==, 'd'); - tt_int_op(hour,==, 15); - tt_ci_char_op(label_h[0],==, 'h'); - tt_int_op(min,==, 30); - tt_ci_char_op(label_m[0],==, 'm'); + tt_int_op(r,OP_EQ, 6); + tt_int_op(day,OP_EQ, 106751991167300L); + tt_ci_char_op(label_d[0],OP_EQ, 'd'); + tt_int_op(hour,OP_EQ, 15); + tt_ci_char_op(label_h[0],OP_EQ, 'h'); + tt_int_op(min,OP_EQ, 30); + tt_ci_char_op(label_m[0],OP_EQ, 'm'); /* and 7 seconds - ignored */

/* INT64_MIN: check that we get the absolute value of interval, @@ -2710,16 +2710,16 @@ test_util_format_time_interval(void *arg) * We expect INT64_MAX */ format_time_interval(dbuf, sizeof(dbuf), -9223372036854775807L - 1L); - tt_int_op(strnlen(dbuf, DBUF_SIZE),<=, DBUF_SIZE - 1); + tt_int_op(strnlen(dbuf, DBUF_SIZE),OP_LE, DBUF_SIZE - 1); r = tor_sscanf(dbuf, TL_ " " TL_ " " TL_, &day, label_d, &hour, label_h, &min, label_m); - tt_int_op(r,==, 6); - tt_int_op(day,==, 106751991167300L); - tt_ci_char_op(label_d[0],==, 'd'); - tt_int_op(hour,==, 15); - tt_ci_char_op(label_h[0],==, 'h'); - tt_int_op(min,==, 30); - tt_ci_char_op(label_m[0],==, 'm'); + tt_int_op(r,OP_EQ, 6); + tt_int_op(day,OP_EQ, 106751991167300L); + tt_ci_char_op(label_d[0],OP_EQ, 'd'); + tt_int_op(hour,OP_EQ, 15); + tt_ci_char_op(label_h[0],OP_EQ, 'h'); + tt_int_op(min,OP_EQ, 30); + tt_ci_char_op(label_m[0],OP_EQ, 'm'); /* and 7 or 8 seconds - ignored */

#endif @@ -2741,30 +2741,30 @@ test_util_path_is_relative(void *arg) { /* OS-independent tests */ (void)arg; - tt_int_op(1,==, path_is_relative("")); - tt_int_op(1,==, path_is_relative("dir")); - tt_int_op(1,==, path_is_relative("dir/")); - tt_int_op(1,==, path_is_relative("./dir")); - tt_int_op(1,==, path_is_relative("../dir")); + tt_int_op(1,OP_EQ, path_is_relative("")); + tt_int_op(1,OP_EQ, path_is_relative("dir")); + tt_int_op(1,OP_EQ, path_is_relative("dir/")); + tt_int_op(1,OP_EQ, path_is_relative("./dir")); + tt_int_op(1,OP_EQ, path_is_relative("../dir"));

- tt_int_op(0,==, path_is_relative("/")); - tt_int_op(0,==, path_is_relative("/dir")); - tt_int_op(0,==, path_is_relative("/dir/")); + tt_int_op(0,OP_EQ, path_is_relative("/")); + tt_int_op(0,OP_EQ, path_is_relative("/dir")); + tt_int_op(0,OP_EQ, path_is_relative("/dir/"));

/* Windows */ #ifdef _WIN32 /* I don't have Windows so I can't test this, hence the "#ifdef 0". These are tests that look useful, so please try to get them running and uncomment if it all works as it should */ - tt_int_op(1,==, path_is_relative("dir")); - tt_int_op(1,==, path_is_relative("dir\")); - tt_int_op(1,==, path_is_relative("dir\a:")); - tt_int_op(1,==, path_is_relative("dir\a:\")); - tt_int_op(1,==, path_is_relative("http:\dir")); - - tt_int_op(0,==, path_is_relative("\dir")); - tt_int_op(0,==, path_is_relative("a:\dir")); - tt_int_op(0,==, path_is_relative("z:\dir")); + tt_int_op(1,OP_EQ, path_is_relative("dir")); + tt_int_op(1,OP_EQ, path_is_relative("dir\")); + tt_int_op(1,OP_EQ, path_is_relative("dir\a:")); + tt_int_op(1,OP_EQ, path_is_relative("dir\a:\")); + tt_int_op(1,OP_EQ, path_is_relative("http:\dir")); + + tt_int_op(0,OP_EQ, path_is_relative("\dir")); + tt_int_op(0,OP_EQ, path_is_relative("a:\dir")); + tt_int_op(0,OP_EQ, path_is_relative("z:\dir")); #endif

done: @@ -2793,7 +2793,7 @@ test_util_mempool(void *arg) tt_assert(pool); tt_assert(pool->new_chunk_capacity >= 10); tt_assert(pool->item_alloc_size >= sizeof(void*)+241); - tt_int_op(pool->item_alloc_size & 0x03,==, 0); + tt_int_op(pool->item_alloc_size & 0x03,OP_EQ, 0); tt_assert(pool->new_chunk_capacity < 60);

allocated = smartlist_new(); @@ -2857,16 +2857,16 @@ test_util_memarea(void *arg) tt_assert(p1+64 <= p2); tt_assert(p2+52 <= p3); /* Make sure we aligned. */ - tt_int_op(((uintptr_t)p1) % sizeof(void*),==, 0); - tt_int_op(((uintptr_t)p2) % sizeof(void*),==, 0); - tt_int_op(((uintptr_t)p3) % sizeof(void*),==, 0); + tt_int_op(((uintptr_t)p1) % sizeof(void*),OP_EQ, 0); + tt_int_op(((uintptr_t)p2) % sizeof(void*),OP_EQ, 0); + tt_int_op(((uintptr_t)p3) % sizeof(void*),OP_EQ, 0); tt_assert(!memarea_owns_ptr(area, p3+8192)); tt_assert(!memarea_owns_ptr(area, p3+30)); tt_assert(tor_mem_is_zero(p2, 52)); /* Make sure we don't overalign. */ p1 = memarea_alloc(area, 1); p2 = memarea_alloc(area, 1); - tt_ptr_op(p1+sizeof(void*),==, p2); + tt_ptr_op(p1+sizeof(void*),OP_EQ, p2); { malloced_ptr = tor_malloc(64); tt_assert(!memarea_owns_ptr(area, malloced_ptr)); @@ -2879,7 +2879,7 @@ test_util_memarea(void *arg) crypto_rand((char*)malloced_ptr, 64); p1 = memarea_memdup(area, malloced_ptr, 64); tt_assert(p1 != malloced_ptr); - tt_mem_op(p1,==, malloced_ptr, 64); + tt_mem_op(p1,OP_EQ, malloced_ptr, 64); tor_free(malloced_ptr); }

@@ -2888,8 +2888,8 @@ test_util_memarea(void *arg) p2 = memarea_strdup(area, "abcd"); tt_assert(p1); tt_assert(p2); - tt_str_op(p1,==, ""); - tt_str_op(p2,==, "abcd"); + tt_str_op(p1,OP_EQ, ""); + tt_str_op(p2,OP_EQ, "abcd");

/* memarea_strndup. */ { @@ -2898,20 +2898,20 @@ test_util_memarea(void *arg) size_t len = strlen(s); p1 = memarea_strndup(area, s, 1000); p2 = memarea_strndup(area, s, 10); - tt_str_op(p1,==, s); + tt_str_op(p1,OP_EQ, s); tt_assert(p2 >= p1 + len + 1); - tt_mem_op(s,==, p2, 10); - tt_int_op(p2[10],==, '\0'); + tt_mem_op(s,OP_EQ, p2, 10); + tt_int_op(p2[10],OP_EQ, '\0'); p3 = memarea_strndup(area, s, len); - tt_str_op(p3,==, s); + tt_str_op(p3,OP_EQ, s); p3 = memarea_strndup(area, s, len-1); - tt_mem_op(s,==, p3, len-1); - tt_int_op(p3[len-1],==, '\0'); + tt_mem_op(s,OP_EQ, p3, len-1); + tt_int_op(p3[len-1],OP_EQ, '\0'); }

memarea_clear(area); p1 = memarea_alloc(area, 1); - tt_ptr_op(p1,==, p1_orig); + tt_ptr_op(p1,OP_EQ, p1_orig); memarea_clear(area);

/* Check for running over an area's size. */ @@ -2944,22 +2944,22 @@ test_util_datadir(void *arg) temp_dir = get_datadir_fname(NULL); f = get_datadir_fname("state"); tor_snprintf(buf, sizeof(buf), "%s"PATH_SEPARATOR"state", temp_dir); - tt_str_op(f,==, buf); + tt_str_op(f,OP_EQ, buf); tor_free(f); f = get_datadir_fname2("cache", "thingy"); tor_snprintf(buf, sizeof(buf), "%s"PATH_SEPARATOR"cache"PATH_SEPARATOR"thingy", temp_dir); - tt_str_op(f,==, buf); + tt_str_op(f,OP_EQ, buf); tor_free(f); f = get_datadir_fname2_suffix("cache", "thingy", ".foo"); tor_snprintf(buf, sizeof(buf), "%s"PATH_SEPARATOR"cache"PATH_SEPARATOR"thingy.foo", temp_dir); - tt_str_op(f,==, buf); + tt_str_op(f,OP_EQ, buf); tor_free(f); f = get_datadir_fname_suffix("cache", ".foo"); tor_snprintf(buf, sizeof(buf), "%s"PATH_SEPARATOR"cache.foo", temp_dir); - tt_str_op(f,==, buf); + tt_str_op(f,OP_EQ, buf);

done: tor_free(f); @@ -3000,43 +3000,43 @@ test_util_strtok(void *arg) "%sthey.seemed;;their!.own;most.perfect;monument%s",pad2,pad2); /* -- "Year's End", Richard Wilbur */

- tt_str_op("Graved",==, tor_strtok_r_impl(buf, " ", &cp1)); - tt_str_op("they",==, tor_strtok_r_impl(buf2, ".!..;!", &cp2)); + tt_str_op("Graved",OP_EQ, tor_strtok_r_impl(buf, " ", &cp1)); + tt_str_op("they",OP_EQ, tor_strtok_r_impl(buf2, ".!..;!", &cp2)); #define S1() tor_strtok_r_impl(NULL, " ", &cp1) #define S2() tor_strtok_r_impl(NULL, ".!..;!", &cp2) - tt_str_op("on",==, S1()); - tt_str_op("the",==, S1()); - tt_str_op("dark",==, S1()); - tt_str_op("seemed",==, S2()); - tt_str_op("their",==, S2()); - tt_str_op("own",==, S2()); - tt_str_op("in",==, S1()); - tt_str_op("gestures",==, S1()); - tt_str_op("of",==, S1()); - tt_str_op("most",==, S2()); - tt_str_op("perfect",==, S2()); - tt_str_op("descent",==, S1()); - tt_str_op("monument",==, S2()); - tt_ptr_op(NULL,==, S1()); - tt_ptr_op(NULL,==, S2()); + tt_str_op("on",OP_EQ, S1()); + tt_str_op("the",OP_EQ, S1()); + tt_str_op("dark",OP_EQ, S1()); + tt_str_op("seemed",OP_EQ, S2()); + tt_str_op("their",OP_EQ, S2()); + tt_str_op("own",OP_EQ, S2()); + tt_str_op("in",OP_EQ, S1()); + tt_str_op("gestures",OP_EQ, S1()); + tt_str_op("of",OP_EQ, S1()); + tt_str_op("most",OP_EQ, S2()); + tt_str_op("perfect",OP_EQ, S2()); + tt_str_op("descent",OP_EQ, S1()); + tt_str_op("monument",OP_EQ, S2()); + tt_ptr_op(NULL,OP_EQ, S1()); + tt_ptr_op(NULL,OP_EQ, S2()); }

buf[0] = 0; - tt_ptr_op(NULL,==, tor_strtok_r_impl(buf, " ", &cp1)); - tt_ptr_op(NULL,==, tor_strtok_r_impl(buf, "!", &cp1)); + tt_ptr_op(NULL,OP_EQ, tor_strtok_r_impl(buf, " ", &cp1)); + tt_ptr_op(NULL,OP_EQ, tor_strtok_r_impl(buf, "!", &cp1));

strlcpy(buf, "Howdy!", sizeof(buf)); - tt_str_op("Howdy",==, tor_strtok_r_impl(buf, "!", &cp1)); - tt_ptr_op(NULL,==, tor_strtok_r_impl(NULL, "!", &cp1)); + tt_str_op("Howdy",OP_EQ, tor_strtok_r_impl(buf, "!", &cp1)); + tt_ptr_op(NULL,OP_EQ, tor_strtok_r_impl(NULL, "!", &cp1));

strlcpy(buf, " ", sizeof(buf)); - tt_ptr_op(NULL,==, tor_strtok_r_impl(buf, " ", &cp1)); + tt_ptr_op(NULL,OP_EQ, tor_strtok_r_impl(buf, " ", &cp1)); strlcpy(buf, " ", sizeof(buf)); - tt_ptr_op(NULL,==, tor_strtok_r_impl(buf, " ", &cp1)); + tt_ptr_op(NULL,OP_EQ, tor_strtok_r_impl(buf, " ", &cp1));

strlcpy(buf, "something ", sizeof(buf)); - tt_str_op("something",==, tor_strtok_r_impl(buf, " ", &cp1)); - tt_ptr_op(NULL,==, tor_strtok_r_impl(NULL, ";", &cp1)); + tt_str_op("something",OP_EQ, tor_strtok_r_impl(buf, " ", &cp1)); + tt_ptr_op(NULL,OP_EQ, tor_strtok_r_impl(NULL, ";", &cp1)); done: ; } @@ -3056,24 +3056,24 @@ test_util_find_str_at_start_of_line(void *ptr)

(void)ptr;

- tt_ptr_op(long_string,==, find_str_at_start_of_line(long_string, "")); - tt_ptr_op(NULL,==, find_str_at_start_of_line(short_string, "nonsense")); - tt_ptr_op(NULL,==, find_str_at_start_of_line(long_string, "nonsense")); - tt_ptr_op(NULL,==, find_str_at_start_of_line(long_string, "\n")); - tt_ptr_op(NULL,==, find_str_at_start_of_line(long_string, "how ")); - tt_ptr_op(NULL,==, find_str_at_start_of_line(long_string, "kitty")); - tt_ptr_op(long_string,==, find_str_at_start_of_line(long_string, "h")); - tt_ptr_op(long_string,==, find_str_at_start_of_line(long_string, "how")); - tt_ptr_op(line2,==, find_str_at_start_of_line(long_string, "he")); - tt_ptr_op(line2,==, find_str_at_start_of_line(long_string, "hell")); - tt_ptr_op(line2,==, find_str_at_start_of_line(long_string, "hello k")); - tt_ptr_op(line2,==, find_str_at_start_of_line(long_string, "hello kitty\n")); - tt_ptr_op(line2,==, + tt_ptr_op(long_string,OP_EQ, find_str_at_start_of_line(long_string, "")); + tt_ptr_op(NULL,OP_EQ, find_str_at_start_of_line(short_string, "nonsense")); + tt_ptr_op(NULL,OP_EQ, find_str_at_start_of_line(long_string, "nonsense")); + tt_ptr_op(NULL,OP_EQ, find_str_at_start_of_line(long_string, "\n")); + tt_ptr_op(NULL,OP_EQ, find_str_at_start_of_line(long_string, "how ")); + tt_ptr_op(NULL,OP_EQ, find_str_at_start_of_line(long_string, "kitty")); + tt_ptr_op(long_string,OP_EQ, find_str_at_start_of_line(long_string, "h")); + tt_ptr_op(long_string,OP_EQ, find_str_at_start_of_line(long_string, "how")); + tt_ptr_op(line2,OP_EQ, find_str_at_start_of_line(long_string, "he")); + tt_ptr_op(line2,OP_EQ, find_str_at_start_of_line(long_string, "hell")); + tt_ptr_op(line2,OP_EQ, find_str_at_start_of_line(long_string, "hello k")); + tt_ptr_op(line2,OP_EQ, find_str_at_start_of_line(long_string, "hello kitty\n")); + tt_ptr_op(line2,OP_EQ, find_str_at_start_of_line(long_string, "hello kitty\nt")); - tt_ptr_op(line3,==, find_str_at_start_of_line(long_string, "third")); - tt_ptr_op(line3,==, find_str_at_start_of_line(long_string, "third line")); - tt_ptr_op(NULL,==, find_str_at_start_of_line(long_string, "third line\n")); - tt_ptr_op(short_line2,==, find_str_at_start_of_line(short_string, + tt_ptr_op(line3,OP_EQ, find_str_at_start_of_line(long_string, "third")); + tt_ptr_op(line3,OP_EQ, find_str_at_start_of_line(long_string, "third line")); + tt_ptr_op(NULL,OP_EQ, find_str_at_start_of_line(long_string, "third line\n")); + tt_ptr_op(short_line2,OP_EQ, find_str_at_start_of_line(short_string, "second line\n")); done: ; @@ -3084,25 +3084,25 @@ test_util_string_is_C_identifier(void *ptr) { (void)ptr;

- tt_int_op(1,==, string_is_C_identifier("string_is_C_identifier")); - tt_int_op(1,==, string_is_C_identifier("_string_is_C_identifier")); - tt_int_op(1,==, string_is_C_identifier("_")); - tt_int_op(1,==, string_is_C_identifier("i")); - tt_int_op(1,==, string_is_C_identifier("_____")); - tt_int_op(1,==, string_is_C_identifier("__00__")); - tt_int_op(1,==, string_is_C_identifier("__init__")); - tt_int_op(1,==, string_is_C_identifier("_0")); - tt_int_op(1,==, string_is_C_identifier("_0string_is_C_identifier")); - tt_int_op(1,==, string_is_C_identifier("_0")); - - tt_int_op(0,==, string_is_C_identifier("0_string_is_C_identifier")); - tt_int_op(0,==, string_is_C_identifier("0")); - tt_int_op(0,==, string_is_C_identifier("")); - tt_int_op(0,==, string_is_C_identifier(";")); - tt_int_op(0,==, string_is_C_identifier("i;")); - tt_int_op(0,==, string_is_C_identifier("_;")); - tt_int_op(0,==, string_is_C_identifier("í")); - tt_int_op(0,==, string_is_C_identifier("ñ")); + tt_int_op(1,OP_EQ, string_is_C_identifier("string_is_C_identifier")); + tt_int_op(1,OP_EQ, string_is_C_identifier("_string_is_C_identifier")); + tt_int_op(1,OP_EQ, string_is_C_identifier("_")); + tt_int_op(1,OP_EQ, string_is_C_identifier("i")); + tt_int_op(1,OP_EQ, string_is_C_identifier("_____")); + tt_int_op(1,OP_EQ, string_is_C_identifier("__00__")); + tt_int_op(1,OP_EQ, string_is_C_identifier("__init__")); + tt_int_op(1,OP_EQ, string_is_C_identifier("_0")); + tt_int_op(1,OP_EQ, string_is_C_identifier("_0string_is_C_identifier")); + tt_int_op(1,OP_EQ, string_is_C_identifier("_0")); + + tt_int_op(0,OP_EQ, string_is_C_identifier("0_string_is_C_identifier")); + tt_int_op(0,OP_EQ, string_is_C_identifier("0")); + tt_int_op(0,OP_EQ, string_is_C_identifier("")); + tt_int_op(0,OP_EQ, string_is_C_identifier(";")); + tt_int_op(0,OP_EQ, string_is_C_identifier("i;")); + tt_int_op(0,OP_EQ, string_is_C_identifier("_;")); + tt_int_op(0,OP_EQ, string_is_C_identifier("í")); + tt_int_op(0,OP_EQ, string_is_C_identifier("ñ"));

done: ; @@ -3120,29 +3120,29 @@ test_util_asprintf(void *ptr) /* simple string */ r = tor_asprintf(&cp, "simple string 100%% safe"); tt_assert(cp); - tt_str_op("simple string 100% safe",==, cp); - tt_int_op(strlen(cp),==, r); + tt_str_op("simple string 100% safe",OP_EQ, cp); + tt_int_op(strlen(cp),OP_EQ, r); tor_free(cp);

/* empty string */ r = tor_asprintf(&cp, "%s", ""); tt_assert(cp); - tt_str_op("",==, cp); - tt_int_op(strlen(cp),==, r); + tt_str_op("",OP_EQ, cp); + tt_int_op(strlen(cp),OP_EQ, r); tor_free(cp);

/* numbers (%i) */ r = tor_asprintf(&cp, "I like numbers-%2i, %i, etc.", -1, 2); tt_assert(cp); - tt_str_op("I like numbers--1, 2, etc.",==, cp); - tt_int_op(strlen(cp),==, r); + tt_str_op("I like numbers--1, 2, etc.",OP_EQ, cp); + tt_int_op(strlen(cp),OP_EQ, r); /* don't free cp; next test uses it. */

/* numbers (%d) */ r = tor_asprintf(&cp2, "First=%d, Second=%d", 101, 202); tt_assert(cp2); - tt_int_op(strlen(cp2),==, r); - tt_str_op("First=101, Second=202",==, cp2); + tt_int_op(strlen(cp2),OP_EQ, r); + tt_str_op("First=101, Second=202",OP_EQ, cp2); tt_assert(cp != cp2); tor_free(cp); tor_free(cp2); @@ -3150,17 +3150,17 @@ test_util_asprintf(void *ptr) /* Glass-box test: a string exactly 128 characters long. */ r = tor_asprintf(&cp, "Lorem1: %sLorem2: %s", LOREMIPSUM, LOREMIPSUM); tt_assert(cp); - tt_int_op(128,==, r); - tt_int_op(cp[128], ==, '\0'); - tt_str_op("Lorem1: "LOREMIPSUM"Lorem2: "LOREMIPSUM,==, cp); + tt_int_op(128,OP_EQ, r); + tt_int_op(cp[128], OP_EQ, '\0'); + tt_str_op("Lorem1: "LOREMIPSUM"Lorem2: "LOREMIPSUM,OP_EQ, cp); tor_free(cp);

/* String longer than 128 characters */ r = tor_asprintf(&cp, "1: %s 2: %s 3: %s", LOREMIPSUM, LOREMIPSUM, LOREMIPSUM); tt_assert(cp); - tt_int_op(strlen(cp),==, r); - tt_str_op("1: "LOREMIPSUM" 2: "LOREMIPSUM" 3: "LOREMIPSUM,==, cp); + tt_int_op(strlen(cp),OP_EQ, r); + tt_str_op("1: "LOREMIPSUM" 2: "LOREMIPSUM" 3: "LOREMIPSUM,OP_EQ, cp);

done: tor_free(cp); @@ -3181,9 +3181,9 @@ test_util_listdir(void *ptr) dir1 = tor_strdup(get_fname("some-directory")); dirname = tor_strdup(get_fname(NULL));

- tt_int_op(0,==, write_str_to_file(fname1, "X\n", 0)); - tt_int_op(0,==, write_str_to_file(fname2, "Y\n", 0)); - tt_int_op(0,==, write_str_to_file(fname3, "Z\n", 0)); + tt_int_op(0,OP_EQ, write_str_to_file(fname1, "X\n", 0)); + tt_int_op(0,OP_EQ, write_str_to_file(fname2, "Y\n", 0)); + tt_int_op(0,OP_EQ, write_str_to_file(fname3, "Z\n", 0)); #ifdef _WIN32 r = mkdir(dir1); #else @@ -3229,9 +3229,9 @@ test_util_parent_dir(void *ptr) int ok; \ cp = tor_strdup(input); \ ok = get_parent_directory(cp); \ - tt_int_op(expect_ok, ==, ok); \ + tt_int_op(expect_ok, OP_EQ, ok); \ if (ok==0) \ - tt_str_op(output, ==, cp); \ + tt_str_op(output, OP_EQ, cp); \ tor_free(cp); \ } while (0);

@@ -3280,32 +3280,32 @@ test_util_ftruncate(void *ptr) fname = get_fname("ftruncate");

fd = tor_open_cloexec(fname, O_WRONLY|O_CREAT, 0600); - tt_int_op(fd, >=, 0); + tt_int_op(fd, OP_GE, 0);

/* Make the file be there. */ - tt_int_op(strlen(message), ==, write_all(fd, message, strlen(message), 0)); - tt_int_op((int)tor_fd_getpos(fd), ==, strlen(message)); - tt_int_op(0, ==, fstat(fd, &st)); - tt_int_op((int)st.st_size, ==, strlen(message)); + tt_int_op(strlen(message), OP_EQ, write_all(fd, message, strlen(message), 0)); + tt_int_op((int)tor_fd_getpos(fd), OP_EQ, strlen(message)); + tt_int_op(0, OP_EQ, fstat(fd, &st)); + tt_int_op((int)st.st_size, OP_EQ, strlen(message));

/* Truncate and see if it got truncated */ - tt_int_op(0, ==, tor_ftruncate(fd)); - tt_int_op((int)tor_fd_getpos(fd), ==, 0); - tt_int_op(0, ==, fstat(fd, &st)); - tt_int_op((int)st.st_size, ==, 0); + tt_int_op(0, OP_EQ, tor_ftruncate(fd)); + tt_int_op((int)tor_fd_getpos(fd), OP_EQ, 0); + tt_int_op(0, OP_EQ, fstat(fd, &st)); + tt_int_op((int)st.st_size, OP_EQ, 0);

/* Replace, and see if it got replaced */ - tt_int_op(strlen(message2), ==, + tt_int_op(strlen(message2), OP_EQ, write_all(fd, message2, strlen(message2), 0)); - tt_int_op((int)tor_fd_getpos(fd), ==, strlen(message2)); - tt_int_op(0, ==, fstat(fd, &st)); - tt_int_op((int)st.st_size, ==, strlen(message2)); + tt_int_op((int)tor_fd_getpos(fd), OP_EQ, strlen(message2)); + tt_int_op(0, OP_EQ, fstat(fd, &st)); + tt_int_op((int)st.st_size, OP_EQ, strlen(message2));

close(fd); fd = -1;

buf = read_file_to_str(fname, 0, NULL); - tt_str_op(message2, ==, buf); + tt_str_op(message2, OP_EQ, buf);

done: if (fd >= 0) @@ -3344,53 +3344,53 @@ test_util_exit_status(void *ptr) (void)ptr;

clear_hex_errno(hex_errno); - tt_str_op("",==, hex_errno); + tt_str_op("",OP_EQ, hex_errno);

clear_hex_errno(hex_errno); n = format_helper_exit_status(0, 0, hex_errno); - tt_str_op("0/0\n",==, hex_errno); - tt_int_op(n,==, strlen(hex_errno)); + tt_str_op("0/0\n",OP_EQ, hex_errno); + tt_int_op(n,OP_EQ, strlen(hex_errno));

#if SIZEOF_INT == 4

clear_hex_errno(hex_errno); n = format_helper_exit_status(0, 0x7FFFFFFF, hex_errno); - tt_str_op("0/7FFFFFFF\n",==, hex_errno); - tt_int_op(n,==, strlen(hex_errno)); + tt_str_op("0/7FFFFFFF\n",OP_EQ, hex_errno); + tt_int_op(n,OP_EQ, strlen(hex_errno));

clear_hex_errno(hex_errno); n = format_helper_exit_status(0xFF, -0x80000000, hex_errno); - tt_str_op("FF/-80000000\n",==, hex_errno); - tt_int_op(n,==, strlen(hex_errno)); - tt_int_op(n,==, HEX_ERRNO_SIZE); + tt_str_op("FF/-80000000\n",OP_EQ, hex_errno); + tt_int_op(n,OP_EQ, strlen(hex_errno)); + tt_int_op(n,OP_EQ, HEX_ERRNO_SIZE);

#elif SIZEOF_INT == 8

clear_hex_errno(hex_errno); n = format_helper_exit_status(0, 0x7FFFFFFFFFFFFFFF, hex_errno); - tt_str_op("0/7FFFFFFFFFFFFFFF\n",==, hex_errno); - tt_int_op(n,==, strlen(hex_errno)); + tt_str_op("0/7FFFFFFFFFFFFFFF\n",OP_EQ, hex_errno); + tt_int_op(n,OP_EQ, strlen(hex_errno));

clear_hex_errno(hex_errno); n = format_helper_exit_status(0xFF, -0x8000000000000000, hex_errno); - tt_str_op("FF/-8000000000000000\n",==, hex_errno); - tt_int_op(n,==, strlen(hex_errno)); - tt_int_op(n,==, HEX_ERRNO_SIZE); + tt_str_op("FF/-8000000000000000\n",OP_EQ, hex_errno); + tt_int_op(n,OP_EQ, strlen(hex_errno)); + tt_int_op(n,OP_EQ, HEX_ERRNO_SIZE);

#endif

clear_hex_errno(hex_errno); n = format_helper_exit_status(0x7F, 0, hex_errno); - tt_str_op("7F/0\n",==, hex_errno); - tt_int_op(n,==, strlen(hex_errno)); + tt_str_op("7F/0\n",OP_EQ, hex_errno); + tt_int_op(n,OP_EQ, strlen(hex_errno));

clear_hex_errno(hex_errno); n = format_helper_exit_status(0x08, -0x242, hex_errno); - tt_str_op("8/-242\n",==, hex_errno); - tt_int_op(n,==, strlen(hex_errno)); + tt_str_op("8/-242\n",OP_EQ, hex_errno); + tt_int_op(n,OP_EQ, strlen(hex_errno));

clear_hex_errno(hex_errno); - tt_str_op("",==, hex_errno); + tt_str_op("",OP_EQ, hex_errno);

done: ; @@ -3417,83 +3417,83 @@ test_util_fgets_eagain(void *ptr)

/* Set up a pipe to test on */ retval = pipe(test_pipe); - tt_int_op(retval, ==, 0); + tt_int_op(retval, OP_EQ, 0);

/* Set up the read-end to be non-blocking */ retval = fcntl(test_pipe[0], F_SETFL, O_NONBLOCK); - tt_int_op(retval, ==, 0); + tt_int_op(retval, OP_EQ, 0);

/* Open it as a stdio stream */ test_stream = fdopen(test_pipe[0], "r"); - tt_ptr_op(test_stream, !=, NULL); + tt_ptr_op(test_stream, OP_NE, NULL);

/* Send in a partial line */ retlen = write(test_pipe[1], "A", 1); - tt_int_op(retlen, ==, 1); + tt_int_op(retlen, OP_EQ, 1); retptr = fgets(buf, sizeof(buf), test_stream); - tt_int_op(errno, ==, EAGAIN); - tt_ptr_op(retptr, ==, buf); - tt_str_op(buf, ==, "A"); + tt_int_op(errno, OP_EQ, EAGAIN); + tt_ptr_op(retptr, OP_EQ, buf); + tt_str_op(buf, OP_EQ, "A"); errno = 0;

/* Send in the rest */ retlen = write(test_pipe[1], "B\n", 2); - tt_int_op(retlen, ==, 2); + tt_int_op(retlen, OP_EQ, 2); retptr = fgets(buf, sizeof(buf), test_stream); - tt_int_op(errno, ==, 0); - tt_ptr_op(retptr, ==, buf); - tt_str_op(buf, ==, "B\n"); + tt_int_op(errno, OP_EQ, 0); + tt_ptr_op(retptr, OP_EQ, buf); + tt_str_op(buf, OP_EQ, "B\n"); errno = 0;

/* Send in a full line */ retlen = write(test_pipe[1], "CD\n", 3); - tt_int_op(retlen, ==, 3); + tt_int_op(retlen, OP_EQ, 3); retptr = fgets(buf, sizeof(buf), test_stream); - tt_int_op(errno, ==, 0); - tt_ptr_op(retptr, ==, buf); - tt_str_op(buf, ==, "CD\n"); + tt_int_op(errno, OP_EQ, 0); + tt_ptr_op(retptr, OP_EQ, buf); + tt_str_op(buf, OP_EQ, "CD\n"); errno = 0;

/* Send in a partial line */ retlen = write(test_pipe[1], "E", 1); - tt_int_op(retlen, ==, 1); + tt_int_op(retlen, OP_EQ, 1); retptr = fgets(buf, sizeof(buf), test_stream); - tt_int_op(errno, ==, EAGAIN); - tt_ptr_op(retptr, ==, buf); - tt_str_op(buf, ==, "E"); + tt_int_op(errno, OP_EQ, EAGAIN); + tt_ptr_op(retptr, OP_EQ, buf); + tt_str_op(buf, OP_EQ, "E"); errno = 0;

/* Send in the rest */ retlen = write(test_pipe[1], "F\n", 2); - tt_int_op(retlen, ==, 2); + tt_int_op(retlen, OP_EQ, 2); retptr = fgets(buf, sizeof(buf), test_stream); - tt_int_op(errno, ==, 0); - tt_ptr_op(retptr, ==, buf); - tt_str_op(buf, ==, "F\n"); + tt_int_op(errno, OP_EQ, 0); + tt_ptr_op(retptr, OP_EQ, buf); + tt_str_op(buf, OP_EQ, "F\n"); errno = 0;

/* Send in a full line and close */ retlen = write(test_pipe[1], "GH", 2); - tt_int_op(retlen, ==, 2); + tt_int_op(retlen, OP_EQ, 2); retval = close(test_pipe[1]); - tt_int_op(retval, ==, 0); + tt_int_op(retval, OP_EQ, 0); test_pipe[1] = -1; retptr = fgets(buf, sizeof(buf), test_stream); - tt_int_op(errno, ==, 0); - tt_ptr_op(retptr, ==, buf); - tt_str_op(buf, ==, "GH"); + tt_int_op(errno, OP_EQ, 0); + tt_ptr_op(retptr, OP_EQ, buf); + tt_str_op(buf, OP_EQ, "GH"); errno = 0;

/* Check for EOF */ retptr = fgets(buf, sizeof(buf), test_stream); - tt_int_op(errno, ==, 0); - tt_ptr_op(retptr, ==, NULL); + tt_int_op(errno, OP_EQ, 0); + tt_ptr_op(retptr, OP_EQ, NULL); retval = feof(test_stream); - tt_int_op(retval, !=, 0); + tt_int_op(retval, OP_NE, 0); errno = 0;

/* Check that buf is unchanged according to C99 and C11 */ - tt_str_op(buf, ==, "GH"); + tt_str_op(buf, OP_EQ, "GH");

done: if (test_stream != NULL) @@ -3568,7 +3568,7 @@ run_util_spawn_background(const char *argv[], const char *expected_out, * but we still need to handle PROCESS_STATUS_RUNNING_OR_NOTRUNNING */ tt_assert(MATCH_PROCESS_STATUS(expected_status, status)); if (status == PROCESS_STATUS_ERROR) { - tt_ptr_op(process_handle, ==, NULL); + tt_ptr_op(process_handle, OP_EQ, NULL); return; }

@@ -3611,20 +3611,20 @@ run_util_spawn_background(const char *argv[], const char *expected_out, sizeof(stdout_buf) - 1); tt_assert(pos >= 0); stdout_buf[pos] = '\0'; - tt_int_op(strlen(expected_out),==, pos); - tt_str_op(expected_out,==, stdout_buf); + tt_int_op(strlen(expected_out),OP_EQ, pos); + tt_str_op(expected_out,OP_EQ, stdout_buf);

notify_pending_waitpid_callbacks();

/* Check it terminated correctly */ retval = tor_get_exit_code(process_handle, 1, &exit_code); - tt_int_op(PROCESS_EXIT_EXITED,==, retval); - tt_int_op(expected_exit,==, exit_code); + tt_int_op(PROCESS_EXIT_EXITED,OP_EQ, retval); + tt_int_op(expected_exit,OP_EQ, exit_code); // TODO: Make test-child exit with something other than 0

#ifndef _WIN32 notify_pending_waitpid_callbacks(); - tt_ptr_op(process_handle->waitpid_cb, ==, NULL); + tt_ptr_op(process_handle->waitpid_cb, OP_EQ, NULL); #endif

/* Check stderr */ @@ -3632,8 +3632,8 @@ run_util_spawn_background(const char *argv[], const char *expected_out, sizeof(stderr_buf) - 1); tt_assert(pos >= 0); stderr_buf[pos] = '\0'; - tt_str_op(expected_err,==, stderr_buf); - tt_int_op(strlen(expected_err),==, pos); + tt_str_op(expected_err,OP_EQ, stderr_buf); + tt_int_op(strlen(expected_err),OP_EQ, pos);

notify_pending_waitpid_callbacks();

@@ -3722,9 +3722,9 @@ test_util_spawn_background_partial_read_impl(int exit_early) #else status = tor_spawn_background(argv[0], argv, NULL, &process_handle); #endif - tt_int_op(expected_status,==, status); + tt_int_op(expected_status,OP_EQ, status); tt_assert(process_handle); - tt_int_op(expected_status,==, process_handle->status); + tt_int_op(expected_status,OP_EQ, process_handle->status);

/* Check stdout */ for (expected_out_ctr = 0; expected_out[expected_out_ctr] != NULL;) { @@ -3745,8 +3745,8 @@ test_util_spawn_background_partial_read_impl(int exit_early)

tt_assert(pos > 0); stdout_buf[pos] = '\0'; - tt_str_op(expected_out[expected_out_ctr],==, stdout_buf); - tt_int_op(strlen(expected_out[expected_out_ctr]),==, pos); + tt_str_op(expected_out[expected_out_ctr],OP_EQ, stdout_buf); + tt_int_op(strlen(expected_out[expected_out_ctr]),OP_EQ, pos); expected_out_ctr++; }

@@ -3761,14 +3761,14 @@ test_util_spawn_background_partial_read_impl(int exit_early) pos = tor_read_all_handle(process_handle->stdout_pipe, stdout_buf, sizeof(stdout_buf) - 1, process_handle); - tt_int_op(0,==, pos); + tt_int_op(0,OP_EQ, pos); #else if (!eof) { /* We should have got all the data, but maybe not the EOF flag */ pos = tor_read_all_handle(process_handle->stdout_handle, stdout_buf, sizeof(stdout_buf) - 1, process_handle, &eof); - tt_int_op(0,==, pos); + tt_int_op(0,OP_EQ, pos); tt_assert(eof); } /* Otherwise, we got the EOF on the last read */ @@ -3776,8 +3776,8 @@ test_util_spawn_background_partial_read_impl(int exit_early)

/* Check it terminated correctly */ retval = tor_get_exit_code(process_handle, 1, &exit_code); - tt_int_op(PROCESS_EXIT_EXITED,==, retval); - tt_int_op(expected_exit,==, exit_code); + tt_int_op(PROCESS_EXIT_EXITED,OP_EQ, retval); + tt_int_op(expected_exit,OP_EQ, exit_code);

// TODO: Make test-child exit with something other than 0

@@ -3786,8 +3786,8 @@ test_util_spawn_background_partial_read_impl(int exit_early) sizeof(stderr_buf) - 1); tt_assert(pos >= 0); stderr_buf[pos] = '\0'; - tt_str_op(expected_err,==, stderr_buf); - tt_int_op(strlen(expected_err),==, pos); + tt_str_op(expected_err,OP_EQ, stderr_buf); + tt_int_op(strlen(expected_err),OP_EQ, pos);

done: tor_process_handle_destroy(process_handle, 1); @@ -3825,8 +3825,8 @@ test_util_spawn_background_waitpid_notify(void *arg) status = tor_spawn_background(argv[0], argv, NULL, &process_handle); #endif

- tt_int_op(status, ==, PROCESS_STATUS_RUNNING); - tt_ptr_op(process_handle, !=, NULL); + tt_int_op(status, OP_EQ, PROCESS_STATUS_RUNNING); + tt_ptr_op(process_handle, OP_NE, NULL);

/* We're not going to look at the stdout/stderr output this time. Instead, * we're testing whether notify_pending_waitpid_calbacks() can report the @@ -3835,14 +3835,14 @@ test_util_spawn_background_waitpid_notify(void *arg)

#ifndef _WIN32 ms_timer = 30*1000; - tt_ptr_op(process_handle->waitpid_cb, !=, NULL); + tt_ptr_op(process_handle->waitpid_cb, OP_NE, NULL); while (process_handle->waitpid_cb && ms_timer > 0) { tor_sleep_msec(100); ms_timer -= 100; notify_pending_waitpid_callbacks(); } - tt_int_op(ms_timer, >, 0); - tt_ptr_op(process_handle->waitpid_cb, ==, NULL); + tt_int_op(ms_timer, OP_GT, 0); + tt_ptr_op(process_handle->waitpid_cb, OP_EQ, NULL); #endif

ms_timer = 30*1000; @@ -3851,9 +3851,9 @@ test_util_spawn_background_waitpid_notify(void *arg) tor_sleep_msec(100); ms_timer -= 100; } - tt_int_op(ms_timer, >, 0); + tt_int_op(ms_timer, OP_GT, 0);

- tt_int_op(retval, ==, PROCESS_EXIT_EXITED); + tt_int_op(retval, OP_EQ, PROCESS_EXIT_EXITED);

done: tor_process_handle_destroy(process_handle, 1); @@ -3899,15 +3899,15 @@ test_util_format_hex_number(void *ptr)

for (i = 0; test_data[i].str != NULL; ++i) { len = format_hex_number_sigsafe(test_data[i].x, buf, sizeof(buf)); - tt_int_op(len,!=, 0); - tt_int_op(len,==, strlen(buf)); - tt_str_op(buf,==, test_data[i].str); + tt_int_op(len,OP_NE, 0); + tt_int_op(len,OP_EQ, strlen(buf)); + tt_str_op(buf,OP_EQ, test_data[i].str); }

- tt_int_op(4,==, format_hex_number_sigsafe(0xffff, buf, 5)); - tt_str_op(buf,==, "FFFF"); - tt_int_op(0,==, format_hex_number_sigsafe(0xffff, buf, 4)); - tt_int_op(0,==, format_hex_number_sigsafe(0, buf, 1)); + tt_int_op(4,OP_EQ, format_hex_number_sigsafe(0xffff, buf, 5)); + tt_str_op(buf,OP_EQ, "FFFF"); + tt_int_op(0,OP_EQ, format_hex_number_sigsafe(0xffff, buf, 4)); + tt_int_op(0,OP_EQ, format_hex_number_sigsafe(0, buf, 1));

done: return; @@ -3943,21 +3943,21 @@ test_util_format_dec_number(void *ptr)

for (i = 0; test_data[i].str != NULL; ++i) { len = format_dec_number_sigsafe(test_data[i].x, buf, sizeof(buf)); - tt_int_op(len,!=, 0); - tt_int_op(len,==, strlen(buf)); - tt_str_op(buf,==, test_data[i].str); + tt_int_op(len,OP_NE, 0); + tt_int_op(len,OP_EQ, strlen(buf)); + tt_str_op(buf,OP_EQ, test_data[i].str);

len = format_dec_number_sigsafe(test_data[i].x, buf, (int)(strlen(test_data[i].str) + 1)); - tt_int_op(len,==, strlen(buf)); - tt_str_op(buf,==, test_data[i].str); + tt_int_op(len,OP_EQ, strlen(buf)); + tt_str_op(buf,OP_EQ, test_data[i].str); }

- tt_int_op(4,==, format_dec_number_sigsafe(7331, buf, 5)); - tt_str_op(buf,==, "7331"); - tt_int_op(0,==, format_dec_number_sigsafe(7331, buf, 4)); - tt_int_op(1,==, format_dec_number_sigsafe(0, buf, 2)); - tt_int_op(0,==, format_dec_number_sigsafe(0, buf, 1)); + tt_int_op(4,OP_EQ, format_dec_number_sigsafe(7331, buf, 5)); + tt_str_op(buf,OP_EQ, "7331"); + tt_int_op(0,OP_EQ, format_dec_number_sigsafe(7331, buf, 4)); + tt_int_op(1,OP_EQ, format_dec_number_sigsafe(0, buf, 2)); + tt_int_op(0,OP_EQ, format_dec_number_sigsafe(0, buf, 1));

done: return; @@ -4006,7 +4006,7 @@ test_util_join_win_cmdline(void *ptr) for (i=0; cmdlines[i]!=NULL; i++) { log_info(LD_GENERAL, "Joining argvs[%d], expecting <%s>", i, cmdlines[i]); joined_argv = tor_join_win_cmdline(argvs[i]); - tt_str_op(cmdlines[i],==, joined_argv); + tt_str_op(cmdlines[i],OP_EQ, joined_argv); tor_free(joined_argv); }

@@ -4061,17 +4061,17 @@ test_util_split_lines(void *ptr) i, tests[i].orig_length); SMARTLIST_FOREACH_BEGIN(sl, const char *, line) { /* Check we have not got too many lines */ - tt_int_op(MAX_SPLIT_LINE_COUNT, >, j); + tt_int_op(MAX_SPLIT_LINE_COUNT, OP_GT, j); /* Check that there actually should be a line here */ tt_assert(tests[i].split_line[j] != NULL); log_info(LD_GENERAL, "Line %d of test %d, should be <%s>", j, i, tests[i].split_line[j]); /* Check that the line is as expected */ - tt_str_op(line,==, tests[i].split_line[j]); + tt_str_op(line,OP_EQ, tests[i].split_line[j]); j++; } SMARTLIST_FOREACH_END(line); /* Check that we didn't miss some lines */ - tt_ptr_op(NULL,==, tests[i].split_line[j]); + tt_ptr_op(NULL,OP_EQ, tests[i].split_line[j]); tor_free(orig_line); smartlist_free(sl); sl = NULL; @@ -4107,7 +4107,7 @@ test_util_di_ops(void *arg) for (i = 0; examples[i].a; ++i) { size_t len = strlen(examples[i].a); int eq1, eq2, neq1, neq2, cmp1, cmp2; - tt_int_op(len,==, strlen(examples[i].b)); + tt_int_op(len,OP_EQ, strlen(examples[i].b)); /* We do all of the operations, with operands in both orders. */ eq1 = tor_memeq(examples[i].a, examples[i].b, len); eq2 = tor_memeq(examples[i].b, examples[i].a, len); @@ -4125,11 +4125,11 @@ test_util_di_ops(void *arg) TT_DIE(("Assertion failed."));

/* Check for consistency of everything else with cmp1 */ - tt_int_op(eq1,==, eq2); - tt_int_op(neq1,==, neq2); - tt_int_op(cmp1,==, -cmp2); - tt_int_op(eq1,==, cmp1 == 0); - tt_int_op(neq1,==, !eq1); + tt_int_op(eq1,OP_EQ, eq2); + tt_int_op(neq1,OP_EQ, neq2); + tt_int_op(cmp1,OP_EQ, -cmp2); + tt_int_op(eq1,OP_EQ, cmp1 == 0); + tt_int_op(neq1,OP_EQ, !eq1); }

{ @@ -4144,22 +4144,22 @@ test_util_di_ops(void *arg) for (i = 0; i < 256; i++) { ii = (uint8_t)i; zz = (uint8_t)z; - tt_int_op(tor_memeq(&zz, &ii, 1),==, zz == ii); - tt_int_op(tor_memcmp(&zz, &ii, 1) > 0 ? GT : EQ,==, zz > ii ? GT : EQ); - tt_int_op(tor_memcmp(&ii, &zz, 1) < 0 ? LT : EQ,==, ii < zz ? LT : EQ); + tt_int_op(tor_memeq(&zz, &ii, 1),OP_EQ, zz == ii); + tt_int_op(tor_memcmp(&zz, &ii, 1) > 0 ? GT : EQ,OP_EQ, zz > ii ? GT : EQ); + tt_int_op(tor_memcmp(&ii, &zz, 1) < 0 ? LT : EQ,OP_EQ, ii < zz ? LT : EQ); } } }

- tt_int_op(1, ==, safe_mem_is_zero("", 0)); - tt_int_op(1, ==, safe_mem_is_zero("", 1)); - tt_int_op(0, ==, safe_mem_is_zero("a", 1)); - tt_int_op(0, ==, safe_mem_is_zero("a", 2)); - tt_int_op(0, ==, safe_mem_is_zero("\0a", 2)); - tt_int_op(1, ==, safe_mem_is_zero("\0\0a", 2)); - tt_int_op(1, ==, safe_mem_is_zero("\0\0\0\0\0\0\0\0", 8)); - tt_int_op(1, ==, safe_mem_is_zero("\0\0\0\0\0\0\0\0a", 8)); - tt_int_op(0, ==, safe_mem_is_zero("\0\0\0\0\0\0\0\0a", 9)); + tt_int_op(1, OP_EQ, safe_mem_is_zero("", 0)); + tt_int_op(1, OP_EQ, safe_mem_is_zero("", 1)); + tt_int_op(0, OP_EQ, safe_mem_is_zero("a", 1)); + tt_int_op(0, OP_EQ, safe_mem_is_zero("a", 2)); + tt_int_op(0, OP_EQ, safe_mem_is_zero("\0a", 2)); + tt_int_op(1, OP_EQ, safe_mem_is_zero("\0\0a", 2)); + tt_int_op(1, OP_EQ, safe_mem_is_zero("\0\0\0\0\0\0\0\0", 8)); + tt_int_op(1, OP_EQ, safe_mem_is_zero("\0\0\0\0\0\0\0\0a", 8)); + tt_int_op(0, OP_EQ, safe_mem_is_zero("\0\0\0\0\0\0\0\0a", 9));

done: ; @@ -4172,12 +4172,12 @@ static void test_util_n_bits_set(void *ptr) { (void)ptr; - tt_int_op(0,==, n_bits_set_u8(0)); - tt_int_op(1,==, n_bits_set_u8(1)); - tt_int_op(3,==, n_bits_set_u8(7)); - tt_int_op(1,==, n_bits_set_u8(8)); - tt_int_op(2,==, n_bits_set_u8(129)); - tt_int_op(8,==, n_bits_set_u8(255)); + tt_int_op(0,OP_EQ, n_bits_set_u8(0)); + tt_int_op(1,OP_EQ, n_bits_set_u8(1)); + tt_int_op(3,OP_EQ, n_bits_set_u8(7)); + tt_int_op(1,OP_EQ, n_bits_set_u8(8)); + tt_int_op(2,OP_EQ, n_bits_set_u8(129)); + tt_int_op(8,OP_EQ, n_bits_set_u8(255)); done: ; } @@ -4198,78 +4198,78 @@ test_util_eat_whitespace(void *ptr) strlcpy(str, "fuubaar", sizeof(str)); for (i = 0; i < sizeof(ws); ++i) { str[0] = ws[i]; - tt_ptr_op(str + 1,==, eat_whitespace(str)); - tt_ptr_op(str + 1,==, eat_whitespace_eos(str, str + strlen(str))); - tt_ptr_op(str + 1,==, eat_whitespace_no_nl(str)); - tt_ptr_op(str + 1,==, eat_whitespace_eos_no_nl(str, str + strlen(str))); + tt_ptr_op(str + 1,OP_EQ, eat_whitespace(str)); + tt_ptr_op(str + 1,OP_EQ, eat_whitespace_eos(str, str + strlen(str))); + tt_ptr_op(str + 1,OP_EQ, eat_whitespace_no_nl(str)); + tt_ptr_op(str + 1,OP_EQ, eat_whitespace_eos_no_nl(str, str + strlen(str))); } str[0] = '\n'; - tt_ptr_op(str + 1,==, eat_whitespace(str)); - tt_ptr_op(str + 1,==, eat_whitespace_eos(str, str + strlen(str))); - tt_ptr_op(str,==, eat_whitespace_no_nl(str)); - tt_ptr_op(str,==, eat_whitespace_eos_no_nl(str, str + strlen(str))); + tt_ptr_op(str + 1,OP_EQ, eat_whitespace(str)); + tt_ptr_op(str + 1,OP_EQ, eat_whitespace_eos(str, str + strlen(str))); + tt_ptr_op(str,OP_EQ, eat_whitespace_no_nl(str)); + tt_ptr_op(str,OP_EQ, eat_whitespace_eos_no_nl(str, str + strlen(str)));

/* Empty string */ strlcpy(str, "", sizeof(str)); - tt_ptr_op(str,==, eat_whitespace(str)); - tt_ptr_op(str,==, eat_whitespace_eos(str, str)); - tt_ptr_op(str,==, eat_whitespace_no_nl(str)); - tt_ptr_op(str,==, eat_whitespace_eos_no_nl(str, str)); + tt_ptr_op(str,OP_EQ, eat_whitespace(str)); + tt_ptr_op(str,OP_EQ, eat_whitespace_eos(str, str)); + tt_ptr_op(str,OP_EQ, eat_whitespace_no_nl(str)); + tt_ptr_op(str,OP_EQ, eat_whitespace_eos_no_nl(str, str));

/* Only ws */ strlcpy(str, " \t\r\n", sizeof(str)); - tt_ptr_op(str + strlen(str),==, eat_whitespace(str)); - tt_ptr_op(str + strlen(str),==, eat_whitespace_eos(str, str + strlen(str))); - tt_ptr_op(str + strlen(str) - 1,==, + tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace(str)); + tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace_eos(str, str + strlen(str))); + tt_ptr_op(str + strlen(str) - 1,OP_EQ, eat_whitespace_no_nl(str)); - tt_ptr_op(str + strlen(str) - 1,==, + tt_ptr_op(str + strlen(str) - 1,OP_EQ, eat_whitespace_eos_no_nl(str, str + strlen(str)));

strlcpy(str, " \t\r ", sizeof(str)); - tt_ptr_op(str + strlen(str),==, eat_whitespace(str)); - tt_ptr_op(str + strlen(str),==, + tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace(str)); + tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace_eos(str, str + strlen(str))); - tt_ptr_op(str + strlen(str),==, eat_whitespace_no_nl(str)); - tt_ptr_op(str + strlen(str),==, + tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace_no_nl(str)); + tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace_eos_no_nl(str, str + strlen(str)));

/* Multiple ws */ strlcpy(str, "fuubaar", sizeof(str)); for (i = 0; i < sizeof(ws); ++i) str[i] = ws[i]; - tt_ptr_op(str + sizeof(ws),==, eat_whitespace(str)); - tt_ptr_op(str + sizeof(ws),==, eat_whitespace_eos(str, str + strlen(str))); - tt_ptr_op(str + sizeof(ws),==, eat_whitespace_no_nl(str)); - tt_ptr_op(str + sizeof(ws),==, + tt_ptr_op(str + sizeof(ws),OP_EQ, eat_whitespace(str)); + tt_ptr_op(str + sizeof(ws),OP_EQ, eat_whitespace_eos(str, str + strlen(str))); + tt_ptr_op(str + sizeof(ws),OP_EQ, eat_whitespace_no_nl(str)); + tt_ptr_op(str + sizeof(ws),OP_EQ, eat_whitespace_eos_no_nl(str, str + strlen(str)));

/* Eat comment */ strlcpy(str, "# Comment \n No Comment", sizeof(str)); - tt_str_op("No Comment",==, eat_whitespace(str)); - tt_str_op("No Comment",==, eat_whitespace_eos(str, str + strlen(str))); - tt_ptr_op(str,==, eat_whitespace_no_nl(str)); - tt_ptr_op(str,==, eat_whitespace_eos_no_nl(str, str + strlen(str))); + tt_str_op("No Comment",OP_EQ, eat_whitespace(str)); + tt_str_op("No Comment",OP_EQ, eat_whitespace_eos(str, str + strlen(str))); + tt_ptr_op(str,OP_EQ, eat_whitespace_no_nl(str)); + tt_ptr_op(str,OP_EQ, eat_whitespace_eos_no_nl(str, str + strlen(str)));

/* Eat comment & ws mix */ strlcpy(str, " # \t Comment \n\t\nNo Comment", sizeof(str)); - tt_str_op("No Comment",==, eat_whitespace(str)); - tt_str_op("No Comment",==, eat_whitespace_eos(str, str + strlen(str))); - tt_ptr_op(str + 1,==, eat_whitespace_no_nl(str)); - tt_ptr_op(str + 1,==, eat_whitespace_eos_no_nl(str, str + strlen(str))); + tt_str_op("No Comment",OP_EQ, eat_whitespace(str)); + tt_str_op("No Comment",OP_EQ, eat_whitespace_eos(str, str + strlen(str))); + tt_ptr_op(str + 1,OP_EQ, eat_whitespace_no_nl(str)); + tt_ptr_op(str + 1,OP_EQ, eat_whitespace_eos_no_nl(str, str + strlen(str)));

/* Eat entire comment */ strlcpy(str, "#Comment", sizeof(str)); - tt_ptr_op(str + strlen(str),==, eat_whitespace(str)); - tt_ptr_op(str + strlen(str),==, eat_whitespace_eos(str, str + strlen(str))); - tt_ptr_op(str,==, eat_whitespace_no_nl(str)); - tt_ptr_op(str,==, eat_whitespace_eos_no_nl(str, str + strlen(str))); + tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace(str)); + tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace_eos(str, str + strlen(str))); + tt_ptr_op(str,OP_EQ, eat_whitespace_no_nl(str)); + tt_ptr_op(str,OP_EQ, eat_whitespace_eos_no_nl(str, str + strlen(str)));

/* Blank line, then comment */ strlcpy(str, " \t\n # Comment", sizeof(str)); - tt_ptr_op(str + strlen(str),==, eat_whitespace(str)); - tt_ptr_op(str + strlen(str),==, eat_whitespace_eos(str, str + strlen(str))); - tt_ptr_op(str + 2,==, eat_whitespace_no_nl(str)); - tt_ptr_op(str + 2,==, eat_whitespace_eos_no_nl(str, str + strlen(str))); + tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace(str)); + tt_ptr_op(str + strlen(str),OP_EQ, eat_whitespace_eos(str, str + strlen(str))); + tt_ptr_op(str + 2,OP_EQ, eat_whitespace_no_nl(str)); + tt_ptr_op(str + 2,OP_EQ, eat_whitespace_eos_no_nl(str, str + strlen(str)));

done: ; @@ -4308,11 +4308,11 @@ test_util_sl_new_from_text_lines(void *ptr) smartlist_t *sl = smartlist_new_from_text_lines("foo\nbar\nbaz\n"); int sl_len = smartlist_len(sl);

- tt_want_int_op(sl_len, ==, 3); + tt_want_int_op(sl_len, OP_EQ, 3);

- if (sl_len > 0) tt_want_str_op(smartlist_get(sl, 0), ==, "foo"); - if (sl_len > 1) tt_want_str_op(smartlist_get(sl, 1), ==, "bar"); - if (sl_len > 2) tt_want_str_op(smartlist_get(sl, 2), ==, "baz"); + if (sl_len > 0) tt_want_str_op(smartlist_get(sl, 0), OP_EQ, "foo"); + if (sl_len > 1) tt_want_str_op(smartlist_get(sl, 1), OP_EQ, "bar"); + if (sl_len > 2) tt_want_str_op(smartlist_get(sl, 2), OP_EQ, "baz");

SMARTLIST_FOREACH(sl, void *, x, tor_free(x)); smartlist_free(sl); @@ -4322,11 +4322,11 @@ test_util_sl_new_from_text_lines(void *ptr) smartlist_t *sl = smartlist_new_from_text_lines("foo\nbar\nbaz"); int sl_len = smartlist_len(sl);

- tt_want_int_op(sl_len, ==, 3); + tt_want_int_op(sl_len, OP_EQ, 3);

- if (sl_len > 0) tt_want_str_op(smartlist_get(sl, 0), ==, "foo"); - if (sl_len > 1) tt_want_str_op(smartlist_get(sl, 1), ==, "bar"); - if (sl_len > 2) tt_want_str_op(smartlist_get(sl, 2), ==, "baz"); + if (sl_len > 0) tt_want_str_op(smartlist_get(sl, 0), OP_EQ, "foo"); + if (sl_len > 1) tt_want_str_op(smartlist_get(sl, 1), OP_EQ, "bar"); + if (sl_len > 2) tt_want_str_op(smartlist_get(sl, 2), OP_EQ, "baz");

SMARTLIST_FOREACH(sl, void *, x, tor_free(x)); smartlist_free(sl); @@ -4336,9 +4336,9 @@ test_util_sl_new_from_text_lines(void *ptr) smartlist_t *sl = smartlist_new_from_text_lines("foo"); int sl_len = smartlist_len(sl);

- tt_want_int_op(sl_len, ==, 1); + tt_want_int_op(sl_len, OP_EQ, 1);

- if (sl_len > 0) tt_want_str_op(smartlist_get(sl, 0), ==, "foo"); + if (sl_len > 0) tt_want_str_op(smartlist_get(sl, 0), OP_EQ, "foo");

SMARTLIST_FOREACH(sl, void *, x, tor_free(x)); smartlist_free(sl); @@ -4348,7 +4348,7 @@ test_util_sl_new_from_text_lines(void *ptr) smartlist_t *sl = smartlist_new_from_text_lines(""); int sl_len = smartlist_len(sl);

- tt_want_int_op(sl_len, ==, 0); + tt_want_int_op(sl_len, OP_EQ, 0);

SMARTLIST_FOREACH(sl, void *, x, tor_free(x)); smartlist_free(sl); @@ -4431,7 +4431,7 @@ test_util_make_environment(void *ptr) smartlist_sort_strings(env_vars_sorted); smartlist_sort_strings(env_vars_in_unixoid_env_block_sorted);

- tt_want_int_op(smartlist_len(env_vars_sorted), ==, + tt_want_int_op(smartlist_len(env_vars_sorted), OP_EQ, smartlist_len(env_vars_in_unixoid_env_block_sorted)); { int len = smartlist_len(env_vars_sorted); @@ -4442,7 +4442,7 @@ test_util_make_environment(void *ptr) }

for (i = 0; i < len; ++i) { - tt_want_str_op(smartlist_get(env_vars_sorted, i), ==, + tt_want_str_op(smartlist_get(env_vars_sorted, i), OP_EQ, smartlist_get(env_vars_in_unixoid_env_block_sorted, i)); } } @@ -4524,7 +4524,7 @@ test_util_set_env_var_in_sl(void *ptr) smartlist_sort_strings(merged_env_vars); smartlist_sort_strings(expected_resulting_env_vars);

- tt_want_int_op(smartlist_len(merged_env_vars), ==, + tt_want_int_op(smartlist_len(merged_env_vars), OP_EQ, smartlist_len(expected_resulting_env_vars)); { int len = smartlist_len(merged_env_vars); @@ -4535,7 +4535,7 @@ test_util_set_env_var_in_sl(void *ptr) }

for (i = 0; i < len; ++i) { - tt_want_str_op(smartlist_get(merged_env_vars, i), ==, + tt_want_str_op(smartlist_get(merged_env_vars, i), OP_EQ, smartlist_get(expected_resulting_env_vars, i)); } } @@ -4562,8 +4562,8 @@ test_util_weak_random(void *arg) for (i = 1; i <= 256; ++i) { for (j=0;j<100;++j) { int r = tor_weak_random_range(&rng, i); - tt_int_op(0, <=, r); - tt_int_op(r, <, i); + tt_int_op(0, OP_LE, r); + tt_int_op(r, OP_LT, i); } }

@@ -4573,7 +4573,7 @@ test_util_weak_random(void *arg) }

for (i=0;i<16;++i) - tt_int_op(n[i], >, 0); + tt_int_op(n[i], OP_GT, 0); done: ; } @@ -4585,9 +4585,9 @@ test_util_mathlog(void *arg) (void) arg;

d = tor_mathlog(2.718281828); - tt_double_op(fabs(d - 1.0), <, .000001); + tt_double_op(fabs(d - 1.0), OP_LT, .000001); d = tor_mathlog(10); - tt_double_op(fabs(d - 2.30258509), <, .000001); + tt_double_op(fabs(d - 2.30258509), OP_LT, .000001); done: ; } @@ -4671,36 +4671,36 @@ test_util_socket(void *arg) fd2 = tor_open_socket_with_extensions(AF_INET, SOCK_STREAM, 0, 0, 1); tt_assert(SOCKET_OK(fd1)); tt_assert(SOCKET_OK(fd2)); - tt_int_op(get_n_open_sockets(), ==, n + 2); + tt_int_op(get_n_open_sockets(), OP_EQ, n + 2); //fd3 = tor_open_socket_with_extensions(AF_INET, SOCK_STREAM, 0, 1, 0); //fd4 = tor_open_socket_with_extensions(AF_INET, SOCK_STREAM, 0, 1, 1); fd3 = tor_open_socket(AF_INET, SOCK_STREAM, 0); fd4 = tor_open_socket_nonblocking(AF_INET, SOCK_STREAM, 0); tt_assert(SOCKET_OK(fd3)); tt_assert(SOCKET_OK(fd4)); - tt_int_op(get_n_open_sockets(), ==, n + 4); + tt_int_op(get_n_open_sockets(), OP_EQ, n + 4);

#ifdef CAN_CHECK_CLOEXEC - tt_int_op(fd_is_cloexec(fd1), ==, 0); - tt_int_op(fd_is_cloexec(fd2), ==, 0); - tt_int_op(fd_is_cloexec(fd3), ==, 1); - tt_int_op(fd_is_cloexec(fd4), ==, 1); + tt_int_op(fd_is_cloexec(fd1), OP_EQ, 0); + tt_int_op(fd_is_cloexec(fd2), OP_EQ, 0); + tt_int_op(fd_is_cloexec(fd3), OP_EQ, 1); + tt_int_op(fd_is_cloexec(fd4), OP_EQ, 1); #endif #ifdef CAN_CHECK_NONBLOCK - tt_int_op(fd_is_nonblocking(fd1), ==, 0); - tt_int_op(fd_is_nonblocking(fd2), ==, 1); - tt_int_op(fd_is_nonblocking(fd3), ==, 0); - tt_int_op(fd_is_nonblocking(fd4), ==, 1); + tt_int_op(fd_is_nonblocking(fd1), OP_EQ, 0); + tt_int_op(fd_is_nonblocking(fd2), OP_EQ, 1); + tt_int_op(fd_is_nonblocking(fd3), OP_EQ, 0); + tt_int_op(fd_is_nonblocking(fd4), OP_EQ, 1); #endif

tor_close_socket(fd1); tor_close_socket(fd2); fd1 = fd2 = TOR_INVALID_SOCKET; - tt_int_op(get_n_open_sockets(), ==, n + 2); + tt_int_op(get_n_open_sockets(), OP_EQ, n + 2); tor_close_socket(fd3); tor_close_socket(fd4); fd3 = fd4 = TOR_INVALID_SOCKET; - tt_int_op(get_n_open_sockets(), ==, n); + tt_int_op(get_n_open_sockets(), OP_EQ, n);

done: if (SOCKET_OK(fd1)) @@ -4742,17 +4742,17 @@ test_util_socketpair(void *arg) tor_socket_t fds[2] = {TOR_INVALID_SOCKET, TOR_INVALID_SOCKET}; const int family = AF_UNIX;

- tt_int_op(0, ==, tor_socketpair_fn(family, SOCK_STREAM, 0, fds)); + tt_int_op(0, OP_EQ, tor_socketpair_fn(family, SOCK_STREAM, 0, fds)); tt_assert(SOCKET_OK(fds[0])); tt_assert(SOCKET_OK(fds[1])); - tt_int_op(get_n_open_sockets(), ==, n + 2); + tt_int_op(get_n_open_sockets(), OP_EQ, n + 2); #ifdef CAN_CHECK_CLOEXEC - tt_int_op(fd_is_cloexec(fds[0]), ==, 1); - tt_int_op(fd_is_cloexec(fds[1]), ==, 1); + tt_int_op(fd_is_cloexec(fds[0]), OP_EQ, 1); + tt_int_op(fd_is_cloexec(fds[1]), OP_EQ, 1); #endif #ifdef CAN_CHECK_NONBLOCK - tt_int_op(fd_is_nonblocking(fds[0]), ==, 0); - tt_int_op(fd_is_nonblocking(fds[1]), ==, 0); + tt_int_op(fd_is_nonblocking(fds[0]), OP_EQ, 0); + tt_int_op(fd_is_nonblocking(fds[1]), OP_EQ, 0); #endif

done: @@ -4771,18 +4771,18 @@ test_util_max_mem(void *arg)

r = get_total_system_memory(&memory1); r2 = get_total_system_memory(&memory2); - tt_int_op(r, ==, r2); - tt_uint_op(memory2, ==, memory1); + tt_int_op(r, OP_EQ, r2); + tt_uint_op(memory2, OP_EQ, memory1);

TT_BLATHER(("System memory: "U64_FORMAT, U64_PRINTF_ARG(memory1)));

if (r==0) { /* You have at least a megabyte. */ - tt_uint_op(memory1, >, (1<<20)); + tt_uint_op(memory1, OP_GT, (1<<20)); } else { /* You do not have a petabyte. */ #if SIZEOF_SIZE_T == SIZEOF_UINT64_T - tt_uint_op(memory1, <, (U64_LITERAL(1)<<50)); + tt_uint_op(memory1, OP_LT, (U64_LITERAL(1)<<50)); #endif }