Fix numerous 64->32 errors in the unit tests

Before the 11825 fix, these were all silently ignored.

diff --git a/src/test/test.h b/src/test/test.h
index 0ccf6c718ea1d43f7d33df2cf0556b982fa74c45..712183f4b2bb55e9903e4fffece48d4030d3a702 100644 (file)
--- a/src/test/test.h
+++ b/src/test/test.h
@@ -59,6 +59,29 @@
   tt_assert_test_type(a,b,#a" "#op" "#b,double,(val1_ op val2_),"%f",   \
                       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);
 crypto_pk_t *pk_generate(int idx);
 

diff --git a/src/test/test_controller_events.c b/src/test/test_controller_events.c
index ee35239e45c30e5dcb6f2fdf3baecce175ba9ce6..b45e97a417f779d8644e691fd1087d337821be18 100644 (file)
--- a/src/test/test_controller_events.c
+++ b/src/test/test_controller_events.c
@@ -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_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. */
   add_testing_cell_stats_entry(circ, CELL_RELAY, 0, 0, 1);
   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
    * 20 msec. */
   add_testing_cell_stats_entry(circ, CELL_RELAY, 2, 1, 0);
   sum_up_cell_stats_by_command(circ, cell_stats);
-  tt_int_op(20, ==, cell_stats->total_time_appward[CELL_RELAY]);
-  tt_int_op(1, ==, cell_stats->removed_cells_appward[CELL_RELAY]);
+  tt_u64_op(20, ==, cell_stats->total_time_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
    * spent 30 msec. */
   add_testing_cell_stats_entry(circ, CELL_RELAY, 3, 1, 1);
   sum_up_cell_stats_by_command(circ, cell_stats);
-  tt_int_op(30, ==, cell_stats->total_time_exitward[CELL_RELAY]);
-  tt_int_op(1, ==, cell_stats->removed_cells_exitward[CELL_RELAY]);
+  tt_u64_op(30, ==, cell_stats->total_time_exitward[CELL_RELAY]);
+  tt_u64_op(1, ==, cell_stats->removed_cells_exitward[CELL_RELAY]);
 
  done:
   tor_free(cell_stats);

diff --git a/src/test/test_crypto.c b/src/test/test_crypto.c
index 1fda334760f8004ed3874055bcf2145212e27686..5d8edb655001bac32565ca77d99b6606c747b771 100644 (file)
--- a/src/test/test_crypto.c
+++ b/src/test/test_crypto.c
@@ -1132,7 +1132,8 @@ test_crypto_curve25519_persist(void *arg)
   content = read_file_to_str(fname, RFTS_BIN, &st);
   tt_assert(content);
   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(tor_mem_is_zero(content+taglen, 32-taglen));
   cp = content + 32;

diff --git a/src/test/test_dir.c b/src/test/test_dir.c
index 90667e9a45e5bffdf0a1f6202fb3cbfe2dbe7d32..c03b63be2754dddbe331a4868b792e8ba730769f 100644 (file)
--- a/src/test/test_dir.c
+++ b/src/test/test_dir.c
@@ -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->dir_port, 8000);
     /* 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,
                        "\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);
     if (voter == 1) {
       /* all except "authority" (1) and "v2dir" (64) */
-      test_eq(vrs->flags, U64_LITERAL(190));
+      tt_u64_op(vrs->flags, ==, U64_LITERAL(190));
     } else {
       /* 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,
                        "\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];
     total += vals[i];
   }
-  tt_int_op(total, ==, 45);
+  tt_u64_op(total, ==, 45);
   for (i=0; i<n; ++i) {
     choice = choose_array_element_by_weight(inp, 10);
     tt_int_op(choice, >=, 0);

diff --git a/src/test/test_extorport.c b/src/test/test_extorport.c
index 64ed24eeeb3e4ed147eae54958f4d59c438b581a..93c8f77d5b37eac9c90d676bd152ec16ec469403 100644 (file)
--- a/src/test/test_extorport.c
+++ b/src/test/test_extorport.c
@@ -202,7 +202,7 @@ test_ext_or_init_auth(void *arg)
   tt_int_op(ext_or_auth_cookie_is_set, ==, 1);
   cp = read_file_to_str(fn, RFTS_BIN, &st);
   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+32, ext_or_auth_cookie, 32);
   memcpy(cookie0, ext_or_auth_cookie, 32);

diff --git a/src/test/test_util.c b/src/test/test_util.c
index 2c29429b898b5265f61bb60ca8d64b50c637039d..6f3b7e30bcd2a8e61a3cf7c8e4226d4892413bc5 100644 (file)
--- a/src/test/test_util.c
+++ b/src/test/test_util.c
@@ -151,7 +151,7 @@ test_util_write_chunks_to_file(void *arg)
   // assert the file has been written (expected size)
   str = read_file_to_str(fname, RFTS_BIN, &st);
   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);
   tor_free(str);
 
@@ -182,14 +182,14 @@ test_util_write_chunks_to_file(void *arg)
   // assert the file has been written (expected size)
   str = read_file_to_str(fname, RFTS_BIN, &st);
   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);
   tor_free(str);
 
   // assert the tempfile still contains the known string
   str = read_file_to_str(tempname, RFTS_BIN, &st);
   tt_assert(str != NULL);
-  tt_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);
 
  done:
@@ -1090,7 +1090,7 @@ test_util_strmisc(void)
     test_eq(i, 0);
     test_eq(0UL, tor_parse_ulong(TOOBIG, 10, 0, ULONG_MAX, &i, NULL));
     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));
     test_eq(i, 0);
   }
@@ -1288,21 +1288,21 @@ test_util_pow2(void)
   test_eq(tor_log2(UINT64_MAX), 63);
 
   /* Test round_to_power_of_2 */
-  test_eq(round_to_power_of_2(120), 128);
-  test_eq(round_to_power_of_2(128), 128);
-  test_eq(round_to_power_of_2(130), 128);
-  test_assert(round_to_power_of_2(U64_LITERAL(40000000000000000)) ==
-              U64_LITERAL(1)<<55);
-  test_assert(round_to_power_of_2(U64_LITERAL(0xffffffffffffffff)) ==
-              U64_LITERAL(1)<<63);
-  test_eq(round_to_power_of_2(0), 1);
-  test_eq(round_to_power_of_2(1), 1);
-  test_eq(round_to_power_of_2(2), 2);
-  test_eq(round_to_power_of_2(3), 2);
-  test_eq(round_to_power_of_2(4), 4);
-  test_eq(round_to_power_of_2(5), 4);
-  test_eq(round_to_power_of_2(6), 4);
-  test_eq(round_to_power_of_2(7), 8);
+  tt_u64_op(round_to_power_of_2(120), ==, 128);
+  tt_u64_op(round_to_power_of_2(128), ==, 128);
+  tt_u64_op(round_to_power_of_2(130), ==, 128);
+  tt_u64_op(round_to_power_of_2(U64_LITERAL(40000000000000000)), ==,
+            U64_LITERAL(1)<<55);
+  tt_u64_op(round_to_power_of_2(U64_LITERAL(0xffffffffffffffff)), ==,
+          U64_LITERAL(1)<<63);
+  tt_u64_op(round_to_power_of_2(0), ==, 1);
+  tt_u64_op(round_to_power_of_2(1), ==, 1);
+  tt_u64_op(round_to_power_of_2(2), ==, 2);
+  tt_u64_op(round_to_power_of_2(3), ==, 2);
+  tt_u64_op(round_to_power_of_2(4), ==, 4);
+  tt_u64_op(round_to_power_of_2(5), ==, 4);
+  tt_u64_op(round_to_power_of_2(6), ==, 4);
+  tt_u64_op(round_to_power_of_2(7), ==, 8);
 
  done:
   ;