nihilist/tor
1
0
Fork 0
mirror of https://gitlab.torproject.org/tpo/core/tor.git synced 2024-11-10 13:13:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

Replace operators used as macro arguments with OP_XX macros

Browse Source 
Part of fix for 13172
This commit is contained in:
Nick Mathewson 2014-11-12 13:28:07 -05:00
parent 2170171d84
commit a3dafd3f58
35 changed files with 3772 additions and 3772 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/common/compat_libevent.c
View File

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

16
src/ext/tinytest_demo.c
View File

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

10
src/or/circuituse.c
View File

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

156
src/test/test.c
View File

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

2
src/test/test.h
View File

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

456
src/test/test_addr.c
View File

@ -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,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,==, 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_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,==, 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,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,==, 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_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);

336
src/test/test_buffers.c
View File

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

774
src/test/test_cell_formats.c
View File

File diff suppressed because it is too large Load Diff

58
src/test/test_cell_queue.c
View File

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

62
src/test/test_checkdir.c
View File

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

128
src/test/test_circuitlist.c
View File

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

8
src/test/test_circuitmux.c
View File

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

50
src/test/test_config.c
View File

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

386
src/test/test_containers.c
View File

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

52
src/test/test_controller_events.c
View File

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

536
src/test/test_crypto.c
View File

File diff suppressed because it is too large Load Diff

698
src/test/test_dir.c
View File

File diff suppressed because it is too large Load Diff

106
src/test/test_entrynodes.c
View File

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

184
src/test/test_extorport.c
View File

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

8
src/test/test_hs.c
View File

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

2
src/test/test_introduce.c
View File

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

30
src/test/test_logging.c
View File

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

156
src/test/test_microdesc.c
View File

@ -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_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, ==, 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);
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->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, ==, 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_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);

4
src/test/test_nodelist.c
View File

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

80
src/test/test_oom.c
View File

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

6
src/test/test_options.c
View File

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

40
src/test/test_policy.c
View File

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

70
src/test/test_pt.c
View File

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

54
src/test/test_relaycell.c
View File

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

52
src/test/test_replay.c
View File

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

16
src/test/test_routerkeys.c
View File

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

276
src/test/test_routerset.c
View File

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

302
src/test/test_socks.c
View File

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

242
src/test/test_status.c
View File

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

2186
src/test/test_util.c
View File

File diff suppressed because it is too large Load Diff