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

Fix numerous 64->32 errors in the unit tests

Browse Source 
Before the 11825 fix, these were all silently ignored.
This commit is contained in:
Nick Mathewson 2014-05-08 14:01:17 -04:00
parent df68478938
commit 28538069b2
6 changed files with 55 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/test/test.h
View File

@ -59,6 +59,29 @@
tt_assert_test_type(a,b,#a" "#op" "#b,double,(val1_ op val2_),"%f", \ tt_assert_test_type(a,b,#a" "#op" "#b,double,(val1_ op val2_),"%f", \
TT_EXIT_TEST_FUNCTION) TT_EXIT_TEST_FUNCTION)
#ifdef _MSC_VER
#define U64_PRINTF_TYPE uint64_t
#define U64_PRINTF_TYPE int64_t
#else
#define U64_PRINTF_TYPE unsigned long long
#define I64_PRINTF_TYPE long long
#endif
#define tt_size_op(a,op,b) \
tt_assert_test_fmt_type(a,b,#a" "#op" "#b,size_t,(val1_ op val2_), \
U64_PRINTF_TYPE, U64_FORMAT, \
{print_ = (U64_PRINTF_TYPE) value_;},{},TT_EXIT_TEST_FUNCTION)
#define tt_u64_op(a,op,b) \
tt_assert_test_fmt_type(a,b,#a" "#op" "#b,uint64_t,(val1_ op val2_), \
U64_PRINTF_TYPE, U64_FORMAT, \
{print_ = (U64_PRINTF_TYPE) value_;},{},TT_EXIT_TEST_FUNCTION)
#define tt_i64_op(a,op,b) \
tt_assert_test_fmt_type(a,b,#a" "#op" "#b,int64_t,(val1_ op val2_), \
I64_PRINTF_TYPE, I64_FORMAT, \
{print_ = (I64_PRINTF_TYPE) value_;},{},TT_EXIT_TEST_FUNCTION)
const char *get_fname(const char *name); const char *get_fname(const char *name);
crypto_pk_t *pk_generate(int idx); crypto_pk_t *pk_generate(int idx);

12
src/test/test_controller_events.c
View File

@ -118,26 +118,26 @@ test_cntev_sum_up_cell_stats(void *arg)
cell_stats = tor_malloc_zero(sizeof(cell_stats_t)); cell_stats = tor_malloc_zero(sizeof(cell_stats_t));
add_testing_cell_stats_entry(circ, CELL_RELAY, 0, 0, 0); add_testing_cell_stats_entry(circ, CELL_RELAY, 0, 0, 0);
sum_up_cell_stats_by_command(circ, cell_stats); sum_up_cell_stats_by_command(circ, cell_stats);
tt_int_op(1, ==, cell_stats->added_cells_appward[CELL_RELAY]); tt_u64_op(1, ==, cell_stats->added_cells_appward[CELL_RELAY]);
/* A single RELAY cell was added to the exitward queue. */ /* A single RELAY cell was added to the exitward queue. */
add_testing_cell_stats_entry(circ, CELL_RELAY, 0, 0, 1); add_testing_cell_stats_entry(circ, CELL_RELAY, 0, 0, 1);
sum_up_cell_stats_by_command(circ, cell_stats); sum_up_cell_stats_by_command(circ, cell_stats);
tt_int_op(1, ==, cell_stats->added_cells_exitward[CELL_RELAY]); tt_u64_op(1, ==, cell_stats->added_cells_exitward[CELL_RELAY]);
/* A single RELAY cell was removed from the appward queue where it spent /* A single RELAY cell was removed from the appward queue where it spent
* 20 msec. */ * 20 msec. */
add_testing_cell_stats_entry(circ, CELL_RELAY, 2, 1, 0); add_testing_cell_stats_entry(circ, CELL_RELAY, 2, 1, 0);
sum_up_cell_stats_by_command(circ, cell_stats); sum_up_cell_stats_by_command(circ, cell_stats);
tt_int_op(20, ==, cell_stats->total_time_appward[CELL_RELAY]); tt_u64_op(20, ==, cell_stats->total_time_appward[CELL_RELAY]);
tt_int_op(1, ==, cell_stats->removed_cells_appward[CELL_RELAY]); tt_u64_op(1, ==, cell_stats->removed_cells_appward[CELL_RELAY]);
/* A single RELAY cell was removed from the exitward queue where it /* A single RELAY cell was removed from the exitward queue where it
* spent 30 msec. */ * spent 30 msec. */
add_testing_cell_stats_entry(circ, CELL_RELAY, 3, 1, 1); add_testing_cell_stats_entry(circ, CELL_RELAY, 3, 1, 1);
sum_up_cell_stats_by_command(circ, cell_stats); sum_up_cell_stats_by_command(circ, cell_stats);
tt_int_op(30, ==, cell_stats->total_time_exitward[CELL_RELAY]); tt_u64_op(30, ==, cell_stats->total_time_exitward[CELL_RELAY]);
tt_int_op(1, ==, cell_stats->removed_cells_exitward[CELL_RELAY]); tt_u64_op(1, ==, cell_stats->removed_cells_exitward[CELL_RELAY]);
done: done:
tor_free(cell_stats); tor_free(cell_stats);

3
src/test/test_crypto.c
View File

@ -1132,7 +1132,8 @@ test_crypto_curve25519_persist(void *arg)
content = read_file_to_str(fname, RFTS_BIN, &st); content = read_file_to_str(fname, RFTS_BIN, &st);
tt_assert(content); tt_assert(content);
taglen = strlen("== c25519v1: testing =="); taglen = strlen("== c25519v1: testing ==");
tt_int_op(st.st_size, ==, 32+CURVE25519_PUBKEY_LEN+CURVE25519_SECKEY_LEN); tt_u64_op((uint64_t)st.st_size, ==,
32+CURVE25519_PUBKEY_LEN+CURVE25519_SECKEY_LEN);
tt_assert(fast_memeq(content, "== c25519v1: testing ==", taglen)); tt_assert(fast_memeq(content, "== c25519v1: testing ==", taglen));
tt_assert(tor_mem_is_zero(content+taglen, 32-taglen)); tt_assert(tor_mem_is_zero(content+taglen, 32-taglen));
cp = content + 32; cp = content + 32;

8
src/test/test_dir.c
View File

@ -1066,7 +1066,7 @@ test_vrs_for_v3ns(vote_routerstatus_t *vrs, int voter, time_t now)
test_eq(rs->or_port, 443); test_eq(rs->or_port, 443);
test_eq(rs->dir_port, 8000); test_eq(rs->dir_port, 8000);
/* no flags except "running" (16) and "v2dir" (64) */ /* no flags except "running" (16) and "v2dir" (64) */
test_eq(vrs->flags, U64_LITERAL(80)); tt_u64_op(vrs->flags, ==, U64_LITERAL(80));
} else if (tor_memeq(rs->identity_digest, } else if (tor_memeq(rs->identity_digest,
"\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5" "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5"
"\x5\x5\x5\x5", "\x5\x5\x5\x5",
@ -1092,10 +1092,10 @@ test_vrs_for_v3ns(vote_routerstatus_t *vrs, int voter, time_t now)
test_eq(rs->ipv6_orport, 4711); test_eq(rs->ipv6_orport, 4711);
if (voter == 1) { if (voter == 1) {
/* all except "authority" (1) and "v2dir" (64) */ /* all except "authority" (1) and "v2dir" (64) */
test_eq(vrs->flags, U64_LITERAL(190)); tt_u64_op(vrs->flags, ==, U64_LITERAL(190));
} else { } else {
/* 1023 - authority(1) - madeofcheese(16) - madeoftin(32) - v2dir(256) */ /* 1023 - authority(1) - madeofcheese(16) - madeoftin(32) - v2dir(256) */
test_eq(vrs->flags, U64_LITERAL(718)); tt_u64_op(vrs->flags, ==, U64_LITERAL(718));
} }
} else if (tor_memeq(rs->identity_digest, } else if (tor_memeq(rs->identity_digest,
"\x33\x33\x33\x33\x33\x33\x33\x33\x33\x33" "\x33\x33\x33\x33\x33\x33\x33\x33\x33\x33"
@ -1775,7 +1775,7 @@ test_dir_random_weighted(void *testdata)
inp[i].u64 = vals[i]; inp[i].u64 = vals[i];
total += vals[i]; total += vals[i];
} }
tt_int_op(total, ==, 45); tt_u64_op(total, ==, 45);
for (i=0; i<n; ++i) { for (i=0; i<n; ++i) {
choice = choose_array_element_by_weight(inp, 10); choice = choose_array_element_by_weight(inp, 10);
tt_int_op(choice, >=, 0); tt_int_op(choice, >=, 0);

2
src/test/test_extorport.c
View File

@ -202,7 +202,7 @@ test_ext_or_init_auth(void *arg)
tt_int_op(ext_or_auth_cookie_is_set, ==, 1); tt_int_op(ext_or_auth_cookie_is_set, ==, 1);
cp = read_file_to_str(fn, RFTS_BIN, &st); cp = read_file_to_str(fn, RFTS_BIN, &st);
tt_ptr_op(cp, !=, NULL); tt_ptr_op(cp, !=, NULL);
tt_int_op(st.st_size, ==, 64); tt_u64_op((uint64_t)st.st_size, ==, 64);
test_memeq(cp, "! Extended ORPort Auth Cookie !\x0a", 32); test_memeq(cp, "! Extended ORPort Auth Cookie !\x0a", 32);
test_memeq(cp+32, ext_or_auth_cookie, 32); test_memeq(cp+32, ext_or_auth_cookie, 32);
memcpy(cookie0, ext_or_auth_cookie, 32); memcpy(cookie0, ext_or_auth_cookie, 32);

34
src/test/test_util.c
View File

@ -151,7 +151,7 @@ test_util_write_chunks_to_file(void *arg)
// assert the file has been written (expected size) // assert the file has been written (expected size)
str = read_file_to_str(fname, RFTS_BIN, &st); str = read_file_to_str(fname, RFTS_BIN, &st);
tt_assert(str != NULL); tt_assert(str != NULL);
tt_int_op(st.st_size, ==, data_str_len); tt_u64_op((uint64_t)st.st_size, ==, data_str_len);
test_mem_op(data_str, ==, str, data_str_len); test_mem_op(data_str, ==, str, data_str_len);
tor_free(str); tor_free(str);
@ -182,14 +182,14 @@ test_util_write_chunks_to_file(void *arg)
// assert the file has been written (expected size) // assert the file has been written (expected size)
str = read_file_to_str(fname, RFTS_BIN, &st); str = read_file_to_str(fname, RFTS_BIN, &st);
tt_assert(str != NULL); tt_assert(str != NULL);
tt_int_op(st.st_size, ==, data_str_len); tt_u64_op((uint64_t)st.st_size, ==, data_str_len);
test_mem_op(data_str, ==, str, data_str_len); test_mem_op(data_str, ==, str, data_str_len);
tor_free(str); tor_free(str);
// assert the tempfile still contains the known string // assert the tempfile still contains the known string
str = read_file_to_str(tempname, RFTS_BIN, &st); str = read_file_to_str(tempname, RFTS_BIN, &st);
tt_assert(str != NULL); tt_assert(str != NULL);
tt_int_op(st.st_size, ==, temp_str_len); tt_int_op((uint64_t)st.st_size, ==, temp_str_len);
test_mem_op(temp_str, ==, str, temp_str_len); test_mem_op(temp_str, ==, str, temp_str_len);
done: done:
@ -1090,7 +1090,7 @@ test_util_strmisc(void)
test_eq(i, 0); test_eq(i, 0);
test_eq(0UL, tor_parse_ulong(TOOBIG, 10, 0, ULONG_MAX, &i, NULL)); test_eq(0UL, tor_parse_ulong(TOOBIG, 10, 0, ULONG_MAX, &i, NULL));
test_eq(i, 0); test_eq(i, 0);
test_eq(U64_LITERAL(0), tor_parse_uint64(TOOBIG, 10, tt_u64_op(U64_LITERAL(0), ==, tor_parse_uint64(TOOBIG, 10,
0, UINT64_MAX, &i, NULL)); 0, UINT64_MAX, &i, NULL));
test_eq(i, 0); test_eq(i, 0);
} }
@ -1288,21 +1288,21 @@ test_util_pow2(void)
test_eq(tor_log2(UINT64_MAX), 63); test_eq(tor_log2(UINT64_MAX), 63);
/* Test round_to_power_of_2 */ /* Test round_to_power_of_2 */
test_eq(round_to_power_of_2(120), 128); tt_u64_op(round_to_power_of_2(120), ==, 128);
test_eq(round_to_power_of_2(128), 128); tt_u64_op(round_to_power_of_2(128), ==, 128);
test_eq(round_to_power_of_2(130), 128); tt_u64_op(round_to_power_of_2(130), ==, 128);
test_assert(round_to_power_of_2(U64_LITERAL(40000000000000000)) == tt_u64_op(round_to_power_of_2(U64_LITERAL(40000000000000000)), ==,
U64_LITERAL(1)<<55); U64_LITERAL(1)<<55);
test_assert(round_to_power_of_2(U64_LITERAL(0xffffffffffffffff)) == tt_u64_op(round_to_power_of_2(U64_LITERAL(0xffffffffffffffff)), ==,
U64_LITERAL(1)<<63); U64_LITERAL(1)<<63);
test_eq(round_to_power_of_2(0), 1); tt_u64_op(round_to_power_of_2(0), ==, 1);
test_eq(round_to_power_of_2(1), 1); tt_u64_op(round_to_power_of_2(1), ==, 1);
test_eq(round_to_power_of_2(2), 2); tt_u64_op(round_to_power_of_2(2), ==, 2);
test_eq(round_to_power_of_2(3), 2); tt_u64_op(round_to_power_of_2(3), ==, 2);
test_eq(round_to_power_of_2(4), 4); tt_u64_op(round_to_power_of_2(4), ==, 4);
test_eq(round_to_power_of_2(5), 4); tt_u64_op(round_to_power_of_2(5), ==, 4);
test_eq(round_to_power_of_2(6), 4); tt_u64_op(round_to_power_of_2(6), ==, 4);
test_eq(round_to_power_of_2(7), 8); tt_u64_op(round_to_power_of_2(7), ==, 8);
done: done:
; ;