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

Remove the legacy_test_helper and legacy_setup wrappers

Browse Source 
These wrappers went into place when the default type for our unit
test functions changed from "void fn(void)" to "void fn(void *arg)".

To generate this patch, I did the same hokey-pokey as before with
replacing all operators used as macro arguments, then I ran a
coccinelle script, then I ran perl script to fix up everything that
used legacy_test_helper, then I manually removed the
legacy_test_helper functions, then I ran a final perl script to put
the operators back how they were.

==============================
 #!/usr/bin/perl -w -i -p

s/==,/_X_EQ_,/g;
s/!=,/_X_NE_,/g;
s/<,/_X_LT_,/g;
s/>,/_X_GT_,/g;
s/>=,/_X_GEQ_,/g;
s/<=,/_X_LEQ_,/g;

--------------------

@@
identifier func =~ "test_.*$";
statement S, S2;
@@
 static void func (
-void
+void *arg
 )
 {
 ... when != S2
+(void) arg;
 S
 ...
 }

--------------------
 #!/usr/bin/perl -w -i -p

s/, *legacy_test_helper, *([^,]+), *\&legacy_setup, *([^\}]+) *}/, $2, $1, NULL, NULL }/g;

--------------------
 #!/usr/bin/perl -w -i -p

s/_X_NEQ_/!=/g;
s/_X_NE_/!=/g;
s/_X_EQ_/==/g;
s/_X_GT_/>/g;
s/_X_LT_/</g;
s/_X_GEQ_/>=/g;
s/_X_LEQ_/<=/g;

--------------------
This commit is contained in:
Nick Mathewson 2014-09-16 09:30:22 -04:00
parent c72a94ea1c
commit a6627fdb80
10 changed files with 179 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
src/test/test.c
View File

@ -232,7 +232,7 @@ free_pregenerated_keys(void)
/** Run unit tests for the onion handshake code. */ /** Run unit tests for the onion handshake code. */
static void static void
test_onion_handshake(void) test_onion_handshake(void *arg)
{ {
/* client-side */ /* client-side */
crypto_dh_t *c_dh = NULL; crypto_dh_t *c_dh = NULL;
@ -245,6 +245,7 @@ test_onion_handshake(void)
/* shared */ /* shared */
crypto_pk_t *pk = NULL, *pk2 = NULL; crypto_pk_t *pk = NULL, *pk2 = NULL;
(void)arg;
pk = pk_generate(0); pk = pk_generate(0);
pk2 = pk_generate(1); pk2 = pk_generate(1);
@ -420,7 +421,7 @@ test_ntor_handshake(void *arg)
/** Run unit tests for the onion queues. */ /** Run unit tests for the onion queues. */
static void static void
test_onion_queues(void) test_onion_queues(void *arg)
{ {
uint8_t buf1[TAP_ONIONSKIN_CHALLENGE_LEN] = {0}; uint8_t buf1[TAP_ONIONSKIN_CHALLENGE_LEN] = {0};
uint8_t buf2[NTOR_ONIONSKIN_LEN] = {0}; uint8_t buf2[NTOR_ONIONSKIN_LEN] = {0};
@ -431,6 +432,7 @@ test_onion_queues(void)
create_cell_t *onionskin = NULL, *create2_ptr; create_cell_t *onionskin = NULL, *create2_ptr;
create_cell_t *create1 = tor_malloc_zero(sizeof(create_cell_t)); create_cell_t *create1 = tor_malloc_zero(sizeof(create_cell_t));
create_cell_t *create2 = tor_malloc_zero(sizeof(create_cell_t)); create_cell_t *create2 = tor_malloc_zero(sizeof(create_cell_t));
(void)arg;
create2_ptr = create2; /* remember, but do not free */ create2_ptr = create2; /* remember, but do not free */
create_cell_init(create1, CELL_CREATE, ONION_HANDSHAKE_TYPE_TAP, create_cell_init(create1, CELL_CREATE, ONION_HANDSHAKE_TYPE_TAP,
@ -466,7 +468,7 @@ test_onion_queues(void)
} }
static void static void
test_circuit_timeout(void) test_circuit_timeout(void *arg)
{ {
/* Plan: /* Plan:
* 1. Generate 1000 samples * 1. Generate 1000 samples
@ -484,6 +486,7 @@ test_circuit_timeout(void)
or_state_t *state=NULL; or_state_t *state=NULL;
int i, runs; int i, runs;
double close_ms; double close_ms;
(void)arg;
circuit_build_times_init(&initial); circuit_build_times_init(&initial);
circuit_build_times_init(&estimate); circuit_build_times_init(&estimate);
circuit_build_times_init(&final); circuit_build_times_init(&final);
@ -619,7 +622,7 @@ test_circuit_timeout(void)
/** Test encoding and parsing of rendezvous service descriptors. */ /** Test encoding and parsing of rendezvous service descriptors. */
static void static void
test_rend_fns(void) test_rend_fns(void *arg)
{ {
rend_service_descriptor_t *generated = NULL, *parsed = NULL; rend_service_descriptor_t *generated = NULL, *parsed = NULL;
char service_id[DIGEST_LEN]; char service_id[DIGEST_LEN];
@ -642,6 +645,7 @@ test_rend_fns(void)
char address6[] = "foo.bar.abcdefghijklmnop.onion"; char address6[] = "foo.bar.abcdefghijklmnop.onion";
char address7[] = ".abcdefghijklmnop.onion"; char address7[] = ".abcdefghijklmnop.onion";
(void)arg;
tt_assert(BAD_HOSTNAME == parse_extended_hostname(address1)); tt_assert(BAD_HOSTNAME == parse_extended_hostname(address1));
tt_assert(ONION_HOSTNAME == parse_extended_hostname(address2)); tt_assert(ONION_HOSTNAME == parse_extended_hostname(address2));
tt_str_op(address2,==, "aaaaaaaaaaaaaaaa"); tt_str_op(address2,==, "aaaaaaaaaaaaaaaa");
@ -771,7 +775,7 @@ test_rend_fns(void)
/** Run unit tests for GeoIP code. */ /** Run unit tests for GeoIP code. */
static void static void
test_geoip(void) test_geoip(void *arg)
{ {
int i, j; int i, j;
time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */ time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */
@ -825,6 +829,7 @@ test_geoip(void)
/* Populate the DB a bit. Add these in order, since we can't do the final /* Populate the DB a bit. Add these in order, since we can't do the final
* 'sort' step. These aren't very good IP addresses, but they're perfectly * 'sort' step. These aren't very good IP addresses, but they're perfectly
* fine uint32_t values. */ * 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("10,50,AB", AF_INET));
tt_int_op(0,==, geoip_parse_entry("52,90,XY", 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("95,100,AB", AF_INET));
@ -1017,7 +1022,7 @@ test_geoip(void)
} }
static void static void
test_geoip_with_pt(void) test_geoip_with_pt(void *arg)
{ {
time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */ time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */
char *s = NULL; char *s = NULL;
@ -1025,6 +1030,7 @@ test_geoip_with_pt(void)
tor_addr_t addr; tor_addr_t addr;
struct in6_addr in6; struct in6_addr in6;
(void)arg;
get_options_mutable()->BridgeRelay = 1; get_options_mutable()->BridgeRelay = 1;
get_options_mutable()->BridgeRecordUsageByCountry = 1; get_options_mutable()->BridgeRecordUsageByCountry = 1;
@ -1093,7 +1099,7 @@ test_geoip_with_pt(void)
/** Run unit tests for stats code. */ /** Run unit tests for stats code. */
static void static void
test_stats(void) test_stats(void *arg)
{ {
time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */ time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */
char *s = NULL; char *s = NULL;
@ -1101,6 +1107,7 @@ test_stats(void)
/* Start with testing exit port statistics; we shouldn't collect exit /* Start with testing exit port statistics; we shouldn't collect exit
* stats without initializing them. */ * stats without initializing them. */
(void)arg;
rep_hist_note_exit_stream_opened(80); rep_hist_note_exit_stream_opened(80);
rep_hist_note_exit_bytes(80, 100, 10000); rep_hist_note_exit_bytes(80, 100, 10000);
s = rep_hist_format_exit_stats(now + 86400); s = rep_hist_format_exit_stats(now + 86400);
@ -1250,35 +1257,10 @@ test_stats(void)
tor_free(s); tor_free(s);
} }
static void *
legacy_test_setup(const struct testcase_t *testcase)
{
return testcase->setup_data;
}
void
legacy_test_helper(void *data)
{
void (*fn)(void) = data;
fn();
}
static int
legacy_test_cleanup(const struct testcase_t *testcase, void *ptr)
{
(void)ptr;
(void)testcase;
return 1;
}
const struct testcase_setup_t legacy_setup = {
legacy_test_setup, legacy_test_cleanup
};
#define ENT(name) \ #define ENT(name) \
{ #name, legacy_test_helper, 0, &legacy_setup, test_ ## name } { #name, test_ ## name , 0, NULL, NULL }
#define FORK(name) \ #define FORK(name) \
{ #name, legacy_test_helper, TT_FORK, &legacy_setup, test_ ## name } { #name, test_ ## name , TT_FORK, NULL, NULL }
static struct testcase_t test_array[] = { static struct testcase_t test_array[] = {
ENT(onion_handshake), ENT(onion_handshake),

3
src/test/test.h
View File

@ -66,9 +66,6 @@
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);
void legacy_test_helper(void *data);
extern const struct testcase_setup_t legacy_setup;
#define US2_CONCAT_2__(a, b) a ## __ ## b #define US2_CONCAT_2__(a, b) a ## __ ## b
#define US_CONCAT_2__(a, b) a ## _ ## b #define US_CONCAT_2__(a, b) a ## _ ## b
#define US_CONCAT_3__(a, b, c) a ## _ ## b ## _ ## c #define US_CONCAT_3__(a, b, c) a ## _ ## b ## _ ## c

11
src/test/test_addr.c
View File

@ -10,13 +10,14 @@
#include "addressmap.h" #include "addressmap.h"
static void static void
test_addr_basic(void) test_addr_basic(void *arg)
{ {
uint32_t u32; uint32_t u32;
uint16_t u16; uint16_t u16;
char *cp; char *cp;
/* Test addr_port_lookup */ /* Test addr_port_lookup */
(void)arg;
cp = NULL; u32 = 3; u16 = 3; cp = NULL; u32 = 3; u16 = 3;
tt_assert(!addr_port_lookup(LOG_WARN, "1.2.3.4", &cp, &u32, &u16)); tt_assert(!addr_port_lookup(LOG_WARN, "1.2.3.4", &cp, &u32, &u16));
tt_str_op(cp,==, "1.2.3.4"); tt_str_op(cp,==, "1.2.3.4");
@ -179,7 +180,7 @@ test_addr_basic(void)
/** Run unit tests for IPv6 encoding/decoding/manipulation functions. */ /** Run unit tests for IPv6 encoding/decoding/manipulation functions. */
static void static void
test_addr_ip6_helpers(void) test_addr_ip6_helpers(void *arg)
{ {
char buf[TOR_ADDR_BUF_LEN], bug[TOR_ADDR_BUF_LEN]; char buf[TOR_ADDR_BUF_LEN], bug[TOR_ADDR_BUF_LEN];
char rbuf[REVERSE_LOOKUP_NAME_BUF_LEN]; char rbuf[REVERSE_LOOKUP_NAME_BUF_LEN];
@ -194,6 +195,7 @@ test_addr_ip6_helpers(void)
struct sockaddr_in6 *sin6; struct sockaddr_in6 *sin6;
/* Test tor_inet_ntop and tor_inet_pton: IPv6 */ /* Test tor_inet_ntop and tor_inet_pton: IPv6 */
(void)arg;
{ {
const char *ip = "2001::1234"; const char *ip = "2001::1234";
const char *ip_ffff = "::ffff:192.168.1.2"; const char *ip_ffff = "::ffff:192.168.1.2";
@ -736,7 +738,7 @@ test_addr_ip6_helpers(void)
/** Test tor_addr_port_parse(). */ /** Test tor_addr_port_parse(). */
static void static void
test_addr_parse(void) test_addr_parse(void *arg)
{ {
int r; int r;
tor_addr_t addr; tor_addr_t addr;
@ -744,6 +746,7 @@ test_addr_parse(void)
uint16_t port = 0; uint16_t port = 0;
/* Correct call. */ /* Correct call. */
(void)arg;
r= tor_addr_port_parse(LOG_DEBUG, r= tor_addr_port_parse(LOG_DEBUG,
"192.0.2.1:1234", "192.0.2.1:1234",
&addr, &port, -1); &addr, &port, -1);
@ -1047,7 +1050,7 @@ test_addr_make_null(void *data)
} }
#define ADDR_LEGACY(name) \ #define ADDR_LEGACY(name) \
{ #name, legacy_test_helper, 0, &legacy_setup, test_addr_ ## name } { #name, test_addr_ ## name , 0, NULL, NULL }
struct testcase_t addr_tests[] = { struct testcase_t addr_tests[] = {
ADDR_LEGACY(basic), ADDR_LEGACY(basic),

36
src/test/test_containers.c
View File

@ -37,7 +37,7 @@ compare_without_first_ch_(const void *a, const void **b)
/** Run unit tests for basic dynamic-sized array functionality. */ /** Run unit tests for basic dynamic-sized array functionality. */
static void static void
test_container_smartlist_basic(void) test_container_smartlist_basic(void *arg)
{ {
smartlist_t *sl; smartlist_t *sl;
char *v0 = tor_strdup("v0"); char *v0 = tor_strdup("v0");
@ -52,6 +52,7 @@ test_container_smartlist_basic(void)
/* XXXX test sort_digests, uniq_strings, uniq_digests */ /* XXXX test sort_digests, uniq_strings, uniq_digests */
/* Test smartlist add, del_keeporder, insert, get. */ /* Test smartlist add, del_keeporder, insert, get. */
(void)arg;
sl = smartlist_new(); sl = smartlist_new();
smartlist_add(sl, v1); smartlist_add(sl, v1);
smartlist_add(sl, v2); smartlist_add(sl, v2);
@ -92,13 +93,14 @@ test_container_smartlist_basic(void)
/** Run unit tests for smartlist-of-strings functionality. */ /** Run unit tests for smartlist-of-strings functionality. */
static void static void
test_container_smartlist_strings(void) test_container_smartlist_strings(void *arg)
{ {
smartlist_t *sl = smartlist_new(); smartlist_t *sl = smartlist_new();
char *cp=NULL, *cp_alloc=NULL; char *cp=NULL, *cp_alloc=NULL;
size_t sz; size_t sz;
/* Test split and join */ /* Test split and join */
(void)arg;
tt_int_op(0,==, smartlist_len(sl)); tt_int_op(0,==, smartlist_len(sl));
smartlist_split_string(sl, "abc", ":", 0, 0); smartlist_split_string(sl, "abc", ":", 0, 0);
tt_int_op(1,==, smartlist_len(sl)); tt_int_op(1,==, smartlist_len(sl));
@ -349,7 +351,7 @@ test_container_smartlist_strings(void)
/** Run unit tests for smartlist set manipulation functions. */ /** Run unit tests for smartlist set manipulation functions. */
static void static void
test_container_smartlist_overlap(void) test_container_smartlist_overlap(void *arg)
{ {
smartlist_t *sl = smartlist_new(); smartlist_t *sl = smartlist_new();
smartlist_t *ints = smartlist_new(); smartlist_t *ints = smartlist_new();
@ -357,6 +359,7 @@ test_container_smartlist_overlap(void)
smartlist_t *evens = smartlist_new(); smartlist_t *evens = smartlist_new();
smartlist_t *primes = smartlist_new(); smartlist_t *primes = smartlist_new();
int i; int i;
(void)arg;
for (i=1; i < 10; i += 2) for (i=1; i < 10; i += 2)
smartlist_add(odds, (void*)(uintptr_t)i); smartlist_add(odds, (void*)(uintptr_t)i);
for (i=0; i < 10; i += 2) for (i=0; i < 10; i += 2)
@ -402,11 +405,12 @@ test_container_smartlist_overlap(void)
/** Run unit tests for smartlist-of-digests functions. */ /** Run unit tests for smartlist-of-digests functions. */
static void static void
test_container_smartlist_digests(void) test_container_smartlist_digests(void *arg)
{ {
smartlist_t *sl = smartlist_new(); smartlist_t *sl = smartlist_new();
/* contains_digest */ /* contains_digest */
(void)arg;
smartlist_add(sl, tor_memdup("AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN)); smartlist_add(sl, tor_memdup("AAAAAAAAAAAAAAAAAAAA", DIGEST_LEN));
smartlist_add(sl, tor_memdup("\00090AAB2AAAAaasdAAAAA", DIGEST_LEN)); smartlist_add(sl, tor_memdup("\00090AAB2AAAAaasdAAAAA", DIGEST_LEN));
smartlist_add(sl, tor_memdup("\00090AAB2AAAAaasdAAAAA", DIGEST_LEN)); smartlist_add(sl, tor_memdup("\00090AAB2AAAAaasdAAAAA", DIGEST_LEN));
@ -435,13 +439,14 @@ test_container_smartlist_digests(void)
/** Run unit tests for concatenate-a-smartlist-of-strings functions. */ /** Run unit tests for concatenate-a-smartlist-of-strings functions. */
static void static void
test_container_smartlist_join(void) test_container_smartlist_join(void *arg)
{ {
smartlist_t *sl = smartlist_new(); smartlist_t *sl = smartlist_new();
smartlist_t *sl2 = smartlist_new(), *sl3 = smartlist_new(), smartlist_t *sl2 = smartlist_new(), *sl3 = smartlist_new(),
*sl4 = smartlist_new(); *sl4 = smartlist_new();
char *joined=NULL; char *joined=NULL;
/* unique, sorted. */ /* unique, sorted. */
(void)arg;
smartlist_split_string(sl, smartlist_split_string(sl,
"Abashments Ambush Anchorman Bacon Banks Borscht " "Abashments Ambush Anchorman Bacon Banks Borscht "
"Bunks Inhumane Insurance Knish Know Manners " "Bunks Inhumane Insurance Knish Know Manners "
@ -532,11 +537,12 @@ test_container_smartlist_ints_eq(void *arg)
/** Run unit tests for bitarray code */ /** Run unit tests for bitarray code */
static void static void
test_container_bitarray(void) test_container_bitarray(void *arg)
{ {
bitarray_t *ba = NULL; bitarray_t *ba = NULL;
int i, j, ok=1; int i, j, ok=1;
(void)arg;
ba = bitarray_init_zero(1); ba = bitarray_init_zero(1);
tt_assert(ba); tt_assert(ba);
tt_assert(! bitarray_is_set(ba, 0)); tt_assert(! bitarray_is_set(ba, 0));
@ -575,7 +581,7 @@ test_container_bitarray(void)
/** Run unit tests for digest set code (implemented as a hashtable or as a /** Run unit tests for digest set code (implemented as a hashtable or as a
* bloom filter) */ * bloom filter) */
static void static void
test_container_digestset(void) test_container_digestset(void *arg)
{ {
smartlist_t *included = smartlist_new(); smartlist_t *included = smartlist_new();
char d[DIGEST_LEN]; char d[DIGEST_LEN];
@ -584,6 +590,7 @@ test_container_digestset(void)
int false_positives = 0; int false_positives = 0;
digestset_t *set = NULL; digestset_t *set = NULL;
(void)arg;
for (i = 0; i < 1000; ++i) { for (i = 0; i < 1000; ++i) {
crypto_rand(d, DIGEST_LEN); crypto_rand(d, DIGEST_LEN);
smartlist_add(included, tor_memdup(d, DIGEST_LEN)); smartlist_add(included, tor_memdup(d, DIGEST_LEN));
@ -628,7 +635,7 @@ compare_strings_for_pqueue_(const void *p1, const void *p2)
/** Run unit tests for heap-based priority queue functions. */ /** Run unit tests for heap-based priority queue functions. */
static void static void
test_container_pqueue(void) test_container_pqueue(void *arg)
{ {
smartlist_t *sl = smartlist_new(); smartlist_t *sl = smartlist_new();
int (*cmp)(const void *, const void*); int (*cmp)(const void *, const void*);
@ -650,6 +657,8 @@ test_container_pqueue(void)
#define OK() smartlist_pqueue_assert_ok(sl, cmp, offset) #define OK() smartlist_pqueue_assert_ok(sl, cmp, offset)
(void)arg;
cmp = compare_strings_for_pqueue_; cmp = compare_strings_for_pqueue_;
smartlist_pqueue_add(sl, cmp, offset, &cows); smartlist_pqueue_add(sl, cmp, offset, &cows);
smartlist_pqueue_add(sl, cmp, offset, &zebras); smartlist_pqueue_add(sl, cmp, offset, &zebras);
@ -725,7 +734,7 @@ test_container_pqueue(void)
/** Run unit tests for string-to-void* map functions */ /** Run unit tests for string-to-void* map functions */
static void static void
test_container_strmap(void) test_container_strmap(void *arg)
{ {
strmap_t *map; strmap_t *map;
strmap_iter_t *iter; strmap_iter_t *iter;
@ -742,6 +751,7 @@ test_container_strmap(void)
char *v104 = tor_strdup("v104"); char *v104 = tor_strdup("v104");
char *v105 = tor_strdup("v105"); char *v105 = tor_strdup("v105");
(void)arg;
map = strmap_new(); map = strmap_new();
tt_assert(map); tt_assert(map);
tt_int_op(strmap_size(map),==, 0); tt_int_op(strmap_size(map),==, 0);
@ -832,7 +842,7 @@ test_container_strmap(void)
/** Run unit tests for getting the median of a list. */ /** Run unit tests for getting the median of a list. */
static void static void
test_container_order_functions(void) test_container_order_functions(void *arg)
{ {
int lst[25], n = 0; int lst[25], n = 0;
unsigned int lst2[25]; unsigned int lst2[25];
@ -840,6 +850,7 @@ test_container_order_functions(void)
#define median() median_int(lst, n) #define median() median_int(lst, n)
(void)arg;
lst[n++] = 12; lst[n++] = 12;
tt_int_op(12,==, median()); /* 12 */ tt_int_op(12,==, median()); /* 12 */
lst[n++] = 77; lst[n++] = 77;
@ -929,7 +940,7 @@ test_container_di_map(void *arg)
/** Run unit tests for fp_pair-to-void* map functions */ /** Run unit tests for fp_pair-to-void* map functions */
static void static void
test_container_fp_pair_map(void) test_container_fp_pair_map(void *arg)
{ {
fp_pair_map_t *map; fp_pair_map_t *map;
fp_pair_t fp1, fp2, fp3, fp4, fp5, fp6; fp_pair_t fp1, fp2, fp3, fp4, fp5, fp6;
@ -944,6 +955,7 @@ test_container_fp_pair_map(void)
char *v104 = tor_strdup("v104"); char *v104 = tor_strdup("v104");
char *v105 = tor_strdup("v105"); char *v105 = tor_strdup("v105");
(void)arg;
map = fp_pair_map_new(); map = fp_pair_map_new();
tt_assert(map); tt_assert(map);
tt_int_op(fp_pair_map_size(map),==, 0); tt_int_op(fp_pair_map_size(map),==, 0);
@ -1024,7 +1036,7 @@ test_container_fp_pair_map(void)
} }
#define CONTAINER_LEGACY(name) \ #define CONTAINER_LEGACY(name) \
{ #name, legacy_test_helper, 0, &legacy_setup, test_container_ ## name } { #name, test_container_ ## name , 0, NULL, NULL }
#define CONTAINER(name, flags) \ #define CONTAINER(name, flags) \
{ #name, test_container_ ## name, (flags), NULL, NULL } { #name, test_container_ ## name, (flags), NULL, NULL }

26
src/test/test_crypto.c
View File

@ -20,7 +20,7 @@ extern const char AUTHORITY_SIGNKEY_A_DIGEST256[];
/** Run unit tests for Diffie-Hellman functionality. */ /** Run unit tests for Diffie-Hellman functionality. */
static void static void
test_crypto_dh(void) test_crypto_dh(void *arg)
{ {
crypto_dh_t *dh1 = crypto_dh_new(DH_TYPE_CIRCUIT); crypto_dh_t *dh1 = crypto_dh_new(DH_TYPE_CIRCUIT);
crypto_dh_t *dh2 = crypto_dh_new(DH_TYPE_CIRCUIT); crypto_dh_t *dh2 = crypto_dh_new(DH_TYPE_CIRCUIT);
@ -30,6 +30,7 @@ test_crypto_dh(void)
char s2[DH_BYTES]; char s2[DH_BYTES];
ssize_t s1len, s2len; ssize_t s1len, s2len;
(void)arg;
tt_int_op(crypto_dh_get_bytes(dh1),==, DH_BYTES); tt_int_op(crypto_dh_get_bytes(dh1),==, DH_BYTES);
tt_int_op(crypto_dh_get_bytes(dh2),==, DH_BYTES); tt_int_op(crypto_dh_get_bytes(dh2),==, DH_BYTES);
@ -63,13 +64,14 @@ test_crypto_dh(void)
/** Run unit tests for our random number generation function and its wrappers. /** Run unit tests for our random number generation function and its wrappers.
*/ */
static void static void
test_crypto_rng(void) test_crypto_rng(void *arg)
{ {
int i, j, allok; int i, j, allok;
char data1[100], data2[100]; char data1[100], data2[100];
double d; double d;
/* Try out RNG. */ /* Try out RNG. */
(void)arg;
tt_assert(! crypto_seed_rng(0)); tt_assert(! crypto_seed_rng(0));
crypto_rand(data1, 100); crypto_rand(data1, 100);
crypto_rand(data2, 100); crypto_rand(data2, 100);
@ -252,7 +254,7 @@ test_crypto_aes(void *arg)
/** Run unit tests for our SHA-1 functionality */ /** Run unit tests for our SHA-1 functionality */
static void static void
test_crypto_sha(void) test_crypto_sha(void *arg)
{ {
crypto_digest_t *d1 = NULL, *d2 = NULL; crypto_digest_t *d1 = NULL, *d2 = NULL;
int i; int i;
@ -263,6 +265,7 @@ test_crypto_sha(void)
char *mem_op_hex_tmp=NULL; char *mem_op_hex_tmp=NULL;
/* Test SHA-1 with a test vector from the specification. */ /* Test SHA-1 with a test vector from the specification. */
(void)arg;
i = crypto_digest(data, "abc", 3); i = crypto_digest(data, "abc", 3);
test_memeq_hex(data, "A9993E364706816ABA3E25717850C26C9CD0D89D"); test_memeq_hex(data, "A9993E364706816ABA3E25717850C26C9CD0D89D");
tt_int_op(i, ==, 0); tt_int_op(i, ==, 0);
@ -392,7 +395,7 @@ test_crypto_sha(void)
/** Run unit tests for our public key crypto functions */ /** Run unit tests for our public key crypto functions */
static void static void
test_crypto_pk(void) test_crypto_pk(void *arg)
{ {
crypto_pk_t *pk1 = NULL, *pk2 = NULL; crypto_pk_t *pk1 = NULL, *pk2 = NULL;
char *encoded = NULL; char *encoded = NULL;
@ -401,6 +404,7 @@ test_crypto_pk(void)
int i, len; int i, len;
/* Public-key ciphers */ /* Public-key ciphers */
(void)arg;
pk1 = pk_generate(0); pk1 = pk_generate(0);
pk2 = crypto_pk_new(); pk2 = crypto_pk_new();
tt_assert(pk1 && pk2); tt_assert(pk1 && pk2);
@ -561,13 +565,14 @@ test_crypto_pk_fingerprints(void *arg)
/** Sanity check for crypto pk digests */ /** Sanity check for crypto pk digests */
static void static void
test_crypto_digests(void) test_crypto_digests(void *arg)
{ {
crypto_pk_t *k = NULL; crypto_pk_t *k = NULL;
ssize_t r; ssize_t r;
digests_t pkey_digests; digests_t pkey_digests;
char digest[DIGEST_LEN]; char digest[DIGEST_LEN];
(void)arg;
k = crypto_pk_new(); k = crypto_pk_new();
tt_assert(k); tt_assert(k);
r = crypto_pk_read_private_key_from_string(k, AUTHORITY_SIGNKEY_3, -1); r = crypto_pk_read_private_key_from_string(k, AUTHORITY_SIGNKEY_3, -1);
@ -591,11 +596,12 @@ test_crypto_digests(void)
/** Run unit tests for misc crypto formatting functionality (base64, base32, /** Run unit tests for misc crypto formatting functionality (base64, base32,
* fingerprints, etc) */ * fingerprints, etc) */
static void static void
test_crypto_formats(void) test_crypto_formats(void *arg)
{ {
char *data1 = NULL, *data2 = NULL, *data3 = NULL; char *data1 = NULL, *data2 = NULL, *data3 = NULL;
int i, j, idx; int i, j, idx;
(void)arg;
data1 = tor_malloc(1024); data1 = tor_malloc(1024);
data2 = tor_malloc(1024); data2 = tor_malloc(1024);
data3 = tor_malloc(1024); data3 = tor_malloc(1024);
@ -696,13 +702,14 @@ test_crypto_formats(void)
/** Run unit tests for our secret-to-key passphrase hashing functionality. */ /** Run unit tests for our secret-to-key passphrase hashing functionality. */
static void static void
test_crypto_s2k(void) test_crypto_s2k(void *arg)
{ {
char buf[29]; char buf[29];
char buf2[29]; char buf2[29];
char *buf3 = NULL; char *buf3 = NULL;
int i; int i;
(void)arg;
memset(buf, 0, sizeof(buf)); memset(buf, 0, sizeof(buf));
memset(buf2, 0, sizeof(buf2)); memset(buf2, 0, sizeof(buf2));
buf3 = tor_malloc(65536); buf3 = tor_malloc(65536);
@ -842,10 +849,11 @@ test_crypto_aes_iv(void *arg)
/** Test base32 decoding. */ /** Test base32 decoding. */
static void static void
test_crypto_base32_decode(void) test_crypto_base32_decode(void *arg)
{ {
char plain[60], encoded[96 + 1], decoded[60]; char plain[60], encoded[96 + 1], decoded[60];
int res; int res;
(void)arg;
crypto_rand(plain, 60); crypto_rand(plain, 60);
/* Encode and decode a random string. */ /* Encode and decode a random string. */
base32_encode(encoded, 96 + 1, plain, 60); base32_encode(encoded, 96 + 1, plain, 60);
@ -1276,7 +1284,7 @@ static const struct testcase_setup_t pass_data = {
}; };
#define CRYPTO_LEGACY(name) \ #define CRYPTO_LEGACY(name) \
{ #name, legacy_test_helper, 0, &legacy_setup, test_crypto_ ## name } { #name, test_crypto_ ## name , 0, NULL, NULL }
struct testcase_t crypto_tests[] = { struct testcase_t crypto_tests[] = {
CRYPTO_LEGACY(formats), CRYPTO_LEGACY(formats),

32
src/test/test_dir.c
View File

@ -25,8 +25,9 @@
#include "test.h" #include "test.h"
static void static void
test_dir_nicknames(void) test_dir_nicknames(void *arg)
{ {
(void)arg;
tt_assert( is_legal_nickname("a")); tt_assert( is_legal_nickname("a"));
tt_assert(!is_legal_nickname("")); tt_assert(!is_legal_nickname(""));
tt_assert(!is_legal_nickname("abcdefghijklmnopqrst")); /* 20 chars */ tt_assert(!is_legal_nickname("abcdefghijklmnopqrst")); /* 20 chars */
@ -73,7 +74,7 @@ test_dir_nicknames(void)
/** Run unit tests for router descriptor generation logic. */ /** Run unit tests for router descriptor generation logic. */
static void static void
test_dir_formats(void) test_dir_formats(void *arg)
{ {
char *buf = NULL; char *buf = NULL;
char buf2[8192]; char buf2[8192];
@ -89,6 +90,7 @@ test_dir_formats(void)
or_options_t *options = get_options_mutable(); or_options_t *options = get_options_mutable();
const addr_policy_t *p; const addr_policy_t *p;
(void)arg;
pk1 = pk_generate(0); pk1 = pk_generate(0);
pk2 = pk_generate(1); pk2 = pk_generate(1);
@ -293,11 +295,12 @@ test_dir_formats(void)
} }
static void static void
test_dir_versions(void) test_dir_versions(void *arg)
{ {
tor_version_t ver1; tor_version_t ver1;
/* Try out version parsing functionality */ /* Try out version parsing functionality */
(void)arg;
tt_int_op(0,==, tor_version_parse("0.3.4pre2-cvs", &ver1)); tt_int_op(0,==, tor_version_parse("0.3.4pre2-cvs", &ver1));
tt_int_op(0,==, ver1.major); tt_int_op(0,==, ver1.major);
tt_int_op(3,==, ver1.minor); tt_int_op(3,==, ver1.minor);
@ -410,11 +413,12 @@ test_dir_versions(void)
/** Run unit tests for directory fp_pair functions. */ /** Run unit tests for directory fp_pair functions. */
static void static void
test_dir_fp_pairs(void) test_dir_fp_pairs(void *arg)
{ {
smartlist_t *sl = smartlist_new(); smartlist_t *sl = smartlist_new();
fp_pair_t *pair; fp_pair_t *pair;
(void)arg;
dir_split_resource_into_fingerprint_pairs( dir_split_resource_into_fingerprint_pairs(
/* Two pairs, out of order, with one duplicate. */ /* Two pairs, out of order, with one duplicate. */
"73656372657420646174612E0000000000FFFFFF-" "73656372657420646174612E0000000000FFFFFF-"
@ -557,7 +561,7 @@ test_dir_split_fps(void *testdata)
} }
static void static void
test_dir_measured_bw_kb(void) test_dir_measured_bw_kb(void *arg)
{ {
measured_bw_line_t mbwl; measured_bw_line_t mbwl;
int i; int i;
@ -605,6 +609,7 @@ test_dir_measured_bw_kb(void)
"end" "end"
}; };
(void)arg;
for (i = 0; strcmp(lines_fail[i], "end"); i++) { for (i = 0; strcmp(lines_fail[i], "end"); i++) {
//fprintf(stderr, "Testing: %s\n", lines_fail[i]); //fprintf(stderr, "Testing: %s\n", lines_fail[i]);
tt_assert(measured_bw_line_parse(&mbwl, lines_fail[i]) == -1); tt_assert(measured_bw_line_parse(&mbwl, lines_fail[i]) == -1);
@ -626,7 +631,7 @@ test_dir_measured_bw_kb(void)
/** Do the measured bandwidth cache unit test */ /** Do the measured bandwidth cache unit test */
static void static void
test_dir_measured_bw_kb_cache(void) test_dir_measured_bw_kb_cache(void *arg)
{ {
/* Initial fake time_t for testing */ /* Initial fake time_t for testing */
time_t curr = MBWC_INIT_TIME; time_t curr = MBWC_INIT_TIME;
@ -637,6 +642,7 @@ test_dir_measured_bw_kb_cache(void)
time_t as_of; time_t as_of;
/* First, clear the cache and assert that it's empty */ /* First, clear the cache and assert that it's empty */
(void)arg;
dirserv_clear_measured_bw_cache(); dirserv_clear_measured_bw_cache();
tt_int_op(dirserv_get_measured_bw_cache_size(),==, 0); tt_int_op(dirserv_get_measured_bw_cache_size(),==, 0);
/* /*
@ -700,7 +706,7 @@ test_dir_measured_bw_kb_cache(void)
} }
static void static void
test_dir_param_voting(void) test_dir_param_voting(void *arg)
{ {
networkstatus_t vote1, vote2, vote3, vote4; networkstatus_t vote1, vote2, vote3, vote4;
smartlist_t *votes = smartlist_new(); smartlist_t *votes = smartlist_new();
@ -709,6 +715,7 @@ test_dir_param_voting(void)
/* dirvote_compute_params only looks at the net_params field of the votes, /* dirvote_compute_params only looks at the net_params field of the votes,
so that's all we need to set. so that's all we need to set.
*/ */
(void)arg;
memset(&vote1, 0, sizeof(vote1)); memset(&vote1, 0, sizeof(vote1));
memset(&vote2, 0, sizeof(vote2)); memset(&vote2, 0, sizeof(vote2));
memset(&vote3, 0, sizeof(vote3)); memset(&vote3, 0, sizeof(vote3));
@ -1693,8 +1700,9 @@ test_a_networkstatus(
/** Run unit tests for generating and parsing V3 consensus networkstatus /** Run unit tests for generating and parsing V3 consensus networkstatus
* documents. */ * documents. */
static void static void
test_dir_v3_networkstatus(void) test_dir_v3_networkstatus(void *arg)
{ {
(void)arg;
test_a_networkstatus(gen_routerstatus_for_v3ns, test_a_networkstatus(gen_routerstatus_for_v3ns,
vote_tweaks_for_v3ns, vote_tweaks_for_v3ns,
test_vrs_for_v3ns, test_vrs_for_v3ns,
@ -2238,9 +2246,10 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now)
*/ */
static void static void
test_dir_clip_unmeasured_bw_kb(void) test_dir_clip_unmeasured_bw_kb(void *arg)
{ {
/* Run the test with the default clip bandwidth */ /* Run the test with the default clip bandwidth */
(void)arg;
alternate_clip_bw = 0; alternate_clip_bw = 0;
test_a_networkstatus(gen_routerstatus_for_umbw, test_a_networkstatus(gen_routerstatus_for_umbw,
vote_tweaks_for_umbw, vote_tweaks_for_umbw,
@ -2255,7 +2264,7 @@ test_dir_clip_unmeasured_bw_kb(void)
*/ */
static void static void
test_dir_clip_unmeasured_bw_kb_alt(void) test_dir_clip_unmeasured_bw_kb_alt(void *arg)
{ {
/* /*
* Try a different one; this value is chosen so that the below-the-cutoff * Try a different one; this value is chosen so that the below-the-cutoff
@ -2263,6 +2272,7 @@ test_dir_clip_unmeasured_bw_kb_alt(void)
* DEFAULT_MAX_UNMEASURED_BW_KB and if the consensus incorrectly uses that * DEFAULT_MAX_UNMEASURED_BW_KB and if the consensus incorrectly uses that
* cutoff it will fail the test. * cutoff it will fail the test.
*/ */
(void)arg;
alternate_clip_bw = 3 * DEFAULT_MAX_UNMEASURED_BW_KB; alternate_clip_bw = 3 * DEFAULT_MAX_UNMEASURED_BW_KB;
test_a_networkstatus(gen_routerstatus_for_umbw, test_a_networkstatus(gen_routerstatus_for_umbw,
vote_tweaks_for_umbw, vote_tweaks_for_umbw,
@ -2374,7 +2384,7 @@ test_dir_http_handling(void *args)
} }
#define DIR_LEGACY(name) \ #define DIR_LEGACY(name) \
{ #name, legacy_test_helper, TT_FORK, &legacy_setup, test_dir_ ## name } { #name, test_dir_ ## name , TT_FORK, NULL, NULL }
#define DIR(name,flags) \ #define DIR(name,flags) \
{ #name, test_dir_##name, (flags), NULL, NULL } { #name, test_dir_##name, (flags), NULL, NULL }

38
src/test/test_introduce.c
View File

@ -394,8 +394,9 @@ make_intro_from_plaintext(
*/ */
static void static void
test_introduce_decrypt_v0(void) test_introduce_decrypt_v0(void *arg)
{ {
(void)arg;
do_decrypt_test(v0_test_plaintext, sizeof(v0_test_plaintext)); do_decrypt_test(v0_test_plaintext, sizeof(v0_test_plaintext));
} }
@ -403,8 +404,9 @@ test_introduce_decrypt_v0(void)
*/ */
static void static void
test_introduce_decrypt_v1(void) test_introduce_decrypt_v1(void *arg)
{ {
(void)arg;
do_decrypt_test(v1_test_plaintext, sizeof(v1_test_plaintext)); do_decrypt_test(v1_test_plaintext, sizeof(v1_test_plaintext));
} }
@ -412,8 +414,9 @@ test_introduce_decrypt_v1(void)
*/ */
static void static void
test_introduce_decrypt_v2(void) test_introduce_decrypt_v2(void *arg)
{ {
(void)arg;
do_decrypt_test(v2_test_plaintext, sizeof(v2_test_plaintext)); do_decrypt_test(v2_test_plaintext, sizeof(v2_test_plaintext));
} }
@ -421,8 +424,9 @@ test_introduce_decrypt_v2(void)
*/ */
static void static void
test_introduce_decrypt_v3(void) test_introduce_decrypt_v3(void *arg)
{ {
(void)arg;
do_decrypt_test( do_decrypt_test(
v3_no_auth_test_plaintext, sizeof(v3_no_auth_test_plaintext)); v3_no_auth_test_plaintext, sizeof(v3_no_auth_test_plaintext));
do_decrypt_test( do_decrypt_test(
@ -433,8 +437,9 @@ test_introduce_decrypt_v3(void)
*/ */
static void static void
test_introduce_early_parse_v0(void) test_introduce_early_parse_v0(void *arg)
{ {
(void)arg;
do_early_parse_test(v0_test_plaintext, sizeof(v0_test_plaintext)); do_early_parse_test(v0_test_plaintext, sizeof(v0_test_plaintext));
} }
@ -442,8 +447,9 @@ test_introduce_early_parse_v0(void)
*/ */
static void static void
test_introduce_early_parse_v1(void) test_introduce_early_parse_v1(void *arg)
{ {
(void)arg;
do_early_parse_test(v1_test_plaintext, sizeof(v1_test_plaintext)); do_early_parse_test(v1_test_plaintext, sizeof(v1_test_plaintext));
} }
@ -451,8 +457,9 @@ test_introduce_early_parse_v1(void)
*/ */
static void static void
test_introduce_early_parse_v2(void) test_introduce_early_parse_v2(void *arg)
{ {
(void)arg;
do_early_parse_test(v2_test_plaintext, sizeof(v2_test_plaintext)); do_early_parse_test(v2_test_plaintext, sizeof(v2_test_plaintext));
} }
@ -460,8 +467,9 @@ test_introduce_early_parse_v2(void)
*/ */
static void static void
test_introduce_early_parse_v3(void) test_introduce_early_parse_v3(void *arg)
{ {
(void)arg;
do_early_parse_test( do_early_parse_test(
v3_no_auth_test_plaintext, sizeof(v3_no_auth_test_plaintext)); v3_no_auth_test_plaintext, sizeof(v3_no_auth_test_plaintext));
do_early_parse_test( do_early_parse_test(
@ -472,8 +480,9 @@ test_introduce_early_parse_v3(void)
*/ */
static void static void
test_introduce_late_parse_v0(void) test_introduce_late_parse_v0(void *arg)
{ {
(void)arg;
do_late_parse_test(v0_test_plaintext, sizeof(v0_test_plaintext)); do_late_parse_test(v0_test_plaintext, sizeof(v0_test_plaintext));
} }
@ -481,8 +490,9 @@ test_introduce_late_parse_v0(void)
*/ */
static void static void
test_introduce_late_parse_v1(void) test_introduce_late_parse_v1(void *arg)
{ {
(void)arg;
do_late_parse_test(v1_test_plaintext, sizeof(v1_test_plaintext)); do_late_parse_test(v1_test_plaintext, sizeof(v1_test_plaintext));
} }
@ -490,8 +500,9 @@ test_introduce_late_parse_v1(void)
*/ */
static void static void
test_introduce_late_parse_v2(void) test_introduce_late_parse_v2(void *arg)
{ {
(void)arg;
do_late_parse_test(v2_test_plaintext, sizeof(v2_test_plaintext)); do_late_parse_test(v2_test_plaintext, sizeof(v2_test_plaintext));
} }
@ -499,8 +510,9 @@ test_introduce_late_parse_v2(void)
*/ */
static void static void
test_introduce_late_parse_v3(void) test_introduce_late_parse_v3(void *arg)
{ {
(void)arg;
do_late_parse_test( do_late_parse_test(
v3_no_auth_test_plaintext, sizeof(v3_no_auth_test_plaintext)); v3_no_auth_test_plaintext, sizeof(v3_no_auth_test_plaintext));
do_late_parse_test( do_late_parse_test(
@ -508,7 +520,7 @@ test_introduce_late_parse_v3(void)
} }
#define INTRODUCE_LEGACY(name) \ #define INTRODUCE_LEGACY(name) \
{ #name, legacy_test_helper, 0, &legacy_setup, test_introduce_ ## name } { #name, test_introduce_ ## name , 0, NULL, NULL }
struct testcase_t introduce_tests[] = { struct testcase_t introduce_tests[] = {
INTRODUCE_LEGACY(early_parse_v0), INTRODUCE_LEGACY(early_parse_v0),

8
src/test/test_pt.c
View File

@ -27,13 +27,14 @@ reset_mp(managed_proxy_t *mp)
} }
static void static void
test_pt_parsing(void) test_pt_parsing(void *arg)
{ {
char line[200]; char line[200];
transport_t *transport = NULL; transport_t *transport = NULL;
tor_addr_t test_addr; tor_addr_t test_addr;
managed_proxy_t *mp = tor_malloc_zero(sizeof(managed_proxy_t)); managed_proxy_t *mp = tor_malloc_zero(sizeof(managed_proxy_t));
(void)arg;
mp->conf_state = PT_PROTO_INFANT; mp->conf_state = PT_PROTO_INFANT;
mp->transports = smartlist_new(); mp->transports = smartlist_new();
@ -187,11 +188,12 @@ test_pt_get_transport_options(void *arg)
} }
static void static void
test_pt_protocol(void) test_pt_protocol(void *arg)
{ {
char line[200]; char line[200];
managed_proxy_t *mp = tor_malloc_zero(sizeof(managed_proxy_t)); managed_proxy_t *mp = tor_malloc_zero(sizeof(managed_proxy_t));
(void)arg;
mp->conf_state = PT_PROTO_LAUNCHED; mp->conf_state = PT_PROTO_LAUNCHED;
mp->transports = smartlist_new(); mp->transports = smartlist_new();
mp->argv = tor_calloc(sizeof(char *), 2); mp->argv = tor_calloc(sizeof(char *), 2);
@ -529,7 +531,7 @@ test_get_pt_proxy_uri(void *arg)
} }
#define PT_LEGACY(name) \ #define PT_LEGACY(name) \
{ #name, legacy_test_helper, 0, &legacy_setup, test_pt_ ## name } { #name, test_pt_ ## name , 0, NULL, NULL }
struct testcase_t pt_tests[] = { struct testcase_t pt_tests[] = {
PT_LEGACY(parsing), PT_LEGACY(parsing),

35
src/test/test_replay.c
View File

@ -18,10 +18,11 @@ static const char *test_buffer =
" mollit anim id est laborum."; " mollit anim id est laborum.";
static void static void
test_replaycache_alloc(void) test_replaycache_alloc(void *arg)
{ {
replaycache_t *r = NULL; replaycache_t *r = NULL;
(void)arg;
r = replaycache_new(600, 300); r = replaycache_new(600, 300);
tt_assert(r != NULL); tt_assert(r != NULL);
@ -32,11 +33,12 @@ test_replaycache_alloc(void)
} }
static void static void
test_replaycache_badalloc(void) test_replaycache_badalloc(void *arg)
{ {
replaycache_t *r = NULL; replaycache_t *r = NULL;
/* Negative horizon should fail */ /* Negative horizon should fail */
(void)arg;
r = replaycache_new(-600, 300); r = replaycache_new(-600, 300);
tt_assert(r == NULL); tt_assert(r == NULL);
/* Negative interval should get adjusted to zero */ /* Negative interval should get adjusted to zero */
@ -55,8 +57,9 @@ test_replaycache_badalloc(void)
} }
static void static void
test_replaycache_free_null(void) test_replaycache_free_null(void *arg)
{ {
(void)arg;
replaycache_free(NULL); replaycache_free(NULL);
/* Assert that we're here without horrible death */ /* Assert that we're here without horrible death */
tt_assert(1); tt_assert(1);
@ -66,11 +69,12 @@ test_replaycache_free_null(void)
} }
static void static void
test_replaycache_miss(void) test_replaycache_miss(void *arg)
{ {
replaycache_t *r = NULL; replaycache_t *r = NULL;
int result; int result;
(void)arg;
r = replaycache_new(600, 300); r = replaycache_new(600, 300);
tt_assert(r != NULL); tt_assert(r != NULL);
@ -92,11 +96,12 @@ test_replaycache_miss(void)
} }
static void static void
test_replaycache_hit(void) test_replaycache_hit(void *arg)
{ {
replaycache_t *r = NULL; replaycache_t *r = NULL;
int result; int result;
(void)arg;
r = replaycache_new(600, 300); r = replaycache_new(600, 300);
tt_assert(r != NULL); tt_assert(r != NULL);
@ -117,11 +122,12 @@ test_replaycache_hit(void)
} }
static void static void
test_replaycache_age(void) test_replaycache_age(void *arg)
{ {
replaycache_t *r = NULL; replaycache_t *r = NULL;
int result; int result;
(void)arg;
r = replaycache_new(600, 300); r = replaycache_new(600, 300);
tt_assert(r != NULL); tt_assert(r != NULL);
@ -147,12 +153,13 @@ test_replaycache_age(void)
} }
static void static void
test_replaycache_elapsed(void) test_replaycache_elapsed(void *arg)
{ {
replaycache_t *r = NULL; replaycache_t *r = NULL;
int result; int result;
time_t elapsed; time_t elapsed;
(void)arg;
r = replaycache_new(600, 300); r = replaycache_new(600, 300);
tt_assert(r != NULL); tt_assert(r != NULL);
@ -174,11 +181,12 @@ test_replaycache_elapsed(void)
} }
static void static void
test_replaycache_noexpire(void) test_replaycache_noexpire(void *arg)
{ {
replaycache_t *r = NULL; replaycache_t *r = NULL;
int result; int result;
(void)arg;
r = replaycache_new(0, 0); r = replaycache_new(0, 0);
tt_assert(r != NULL); tt_assert(r != NULL);
@ -204,11 +212,12 @@ test_replaycache_noexpire(void)
} }
static void static void
test_replaycache_scrub(void) test_replaycache_scrub(void *arg)
{ {
replaycache_t *r = NULL; replaycache_t *r = NULL;
int result; int result;
(void)arg;
r = replaycache_new(600, 300); r = replaycache_new(600, 300);
tt_assert(r != NULL); tt_assert(r != NULL);
@ -245,12 +254,13 @@ test_replaycache_scrub(void)
} }
static void static void
test_replaycache_future(void) test_replaycache_future(void *arg)
{ {
replaycache_t *r = NULL; replaycache_t *r = NULL;
int result; int result;
time_t elapsed = 0; time_t elapsed = 0;
(void)arg;
r = replaycache_new(600, 300); r = replaycache_new(600, 300);
tt_assert(r != NULL); tt_assert(r != NULL);
@ -288,7 +298,7 @@ test_replaycache_future(void)
} }
static void static void
test_replaycache_realtime(void) test_replaycache_realtime(void *arg)
{ {
replaycache_t *r = NULL; replaycache_t *r = NULL;
/* /*
@ -299,6 +309,7 @@ test_replaycache_realtime(void)
int result; int result;
/* Test the realtime as well as *_internal() entry points */ /* Test the realtime as well as *_internal() entry points */
(void)arg;
r = replaycache_new(600, 300); r = replaycache_new(600, 300);
tt_assert(r != NULL); tt_assert(r != NULL);
@ -329,7 +340,7 @@ test_replaycache_realtime(void)
} }
#define REPLAYCACHE_LEGACY(name) \ #define REPLAYCACHE_LEGACY(name) \
{ #name, legacy_test_helper, 0, &legacy_setup, test_replaycache_ ## name } { #name, test_replaycache_ ## name , 0, NULL, NULL }
struct testcase_t replaycache_tests[] = { struct testcase_t replaycache_tests[] = {
REPLAYCACHE_LEGACY(alloc), REPLAYCACHE_LEGACY(alloc),

62
src/test/test_util.c
View File

@ -229,7 +229,7 @@ test_util_write_chunks_to_file(void *arg)
} }
static void static void
test_util_time(void) test_util_time(void *arg)
{ {
struct timeval start, end; struct timeval start, end;
struct tm a_time; struct tm a_time;
@ -240,6 +240,7 @@ test_util_time(void)
/* Test tv_udiff */ /* Test tv_udiff */
(void)arg;
start.tv_sec = 5; start.tv_sec = 5;
start.tv_usec = 5000; start.tv_usec = 5000;
@ -459,13 +460,14 @@ test_util_parse_http_time(void *arg)
} }
static void static void
test_util_config_line(void) test_util_config_line(void *arg)
{ {
char buf[1024]; char buf[1024];
char *k=NULL, *v=NULL; char *k=NULL, *v=NULL;
const char *str; const char *str;
/* Test parse_config_line_from_str */ /* Test parse_config_line_from_str */
(void)arg;
strlcpy(buf, "k v\n" " key value with spaces \n" "keykey val\n" strlcpy(buf, "k v\n" " key value with spaces \n" "keykey val\n"
"k2\n" "k2\n"
"k3 \n" "\n" " \n" "#comment\n" "k3 \n" "\n" " \n" "#comment\n"
@ -596,7 +598,7 @@ test_util_config_line(void)
} }
static void static void
test_util_config_line_quotes(void) test_util_config_line_quotes(void *arg)
{ {
char buf1[1024]; char buf1[1024];
char buf2[128]; char buf2[128];
@ -606,6 +608,7 @@ test_util_config_line_quotes(void)
const char *str; const char *str;
/* Test parse_config_line_from_str */ /* Test parse_config_line_from_str */
(void)arg;
strlcpy(buf1, "kTrailingSpace \"quoted value\" \n" strlcpy(buf1, "kTrailingSpace \"quoted value\" \n"
"kTrailingGarbage \"quoted value\"trailing garbage\n" "kTrailingGarbage \"quoted value\"trailing garbage\n"
, sizeof(buf1)); , sizeof(buf1));
@ -650,13 +653,14 @@ test_util_config_line_quotes(void)
} }
static void static void
test_util_config_line_comment_character(void) test_util_config_line_comment_character(void *arg)
{ {
char buf[1024]; char buf[1024];
char *k=NULL, *v=NULL; char *k=NULL, *v=NULL;
const char *str; const char *str;
/* Test parse_config_line_from_str */ /* Test parse_config_line_from_str */
(void)arg;
strlcpy(buf, "k1 \"# in quotes\"\n" strlcpy(buf, "k1 \"# in quotes\"\n"
"k2 some value # some comment\n" "k2 some value # some comment\n"
"k3 /home/user/myTorNetwork#2\n" /* Testcase for #1323 */ "k3 /home/user/myTorNetwork#2\n" /* Testcase for #1323 */
@ -690,7 +694,7 @@ test_util_config_line_comment_character(void)
} }
static void static void
test_util_config_line_escaped_content(void) test_util_config_line_escaped_content(void *arg)
{ {
char buf1[1024]; char buf1[1024];
char buf2[128]; char buf2[128];
@ -702,6 +706,7 @@ test_util_config_line_escaped_content(void)
const char *str; const char *str;
/* Test parse_config_line_from_str */ /* Test parse_config_line_from_str */
(void)arg;
strlcpy(buf1, "HexadecimalLower \"\\x2a\"\n" strlcpy(buf1, "HexadecimalLower \"\\x2a\"\n"
"HexadecimalUpper \"\\x2A\"\n" "HexadecimalUpper \"\\x2A\"\n"
"HexadecimalUpperX \"\\X2A\"\n" "HexadecimalUpperX \"\\X2A\"\n"
@ -827,10 +832,11 @@ test_util_config_line_escaped_content(void)
#ifndef _WIN32 #ifndef _WIN32
static void static void
test_util_expand_filename(void) test_util_expand_filename(void *arg)
{ {
char *str; char *str;
(void)arg;
setenv("HOME", "/home/itv", 1); /* For "internal test value" */ setenv("HOME", "/home/itv", 1); /* For "internal test value" */
str = expand_filename(""); str = expand_filename("");
@ -925,11 +931,12 @@ test_util_expand_filename(void)
/** Test tor_escape_str_for_pt_args(). */ /** Test tor_escape_str_for_pt_args(). */
static void static void
test_util_escape_string_socks(void) test_util_escape_string_socks(void *arg)
{ {
char *escaped_string = NULL; char *escaped_string = NULL;
/** Simple backslash escape. */ /** Simple backslash escape. */
(void)arg;
escaped_string = tor_escape_str_for_pt_args("This is a backslash: \\",";\\"); escaped_string = tor_escape_str_for_pt_args("This is a backslash: \\",";\\");
tt_assert(escaped_string); tt_assert(escaped_string);
tt_str_op(escaped_string,==, "This is a backslash: \\\\"); tt_str_op(escaped_string,==, "This is a backslash: \\\\");
@ -983,13 +990,14 @@ test_util_string_is_key_value(void *ptr)
/** Test basic string functionality. */ /** Test basic string functionality. */
static void static void
test_util_strmisc(void) test_util_strmisc(void *arg)
{ {
char buf[1024]; char buf[1024];
int i; int i;
char *cp, *cp_tmp = NULL; char *cp, *cp_tmp = NULL;
/* Test strl operations */ /* Test strl operations */
(void)arg;
tt_int_op(5,==, strlcpy(buf, "Hello", 0)); tt_int_op(5,==, strlcpy(buf, "Hello", 0));
tt_int_op(5,==, strlcpy(buf, "Hello", 10)); tt_int_op(5,==, strlcpy(buf, "Hello", 10));
tt_str_op(buf,==, "Hello"); tt_str_op(buf,==, "Hello");
@ -1297,9 +1305,10 @@ test_util_strmisc(void)
} }
static void static void
test_util_pow2(void) test_util_pow2(void *arg)
{ {
/* Test tor_log2(). */ /* Test tor_log2(). */
(void)arg;
tt_int_op(tor_log2(64),==, 6); tt_int_op(tor_log2(64),==, 6);
tt_int_op(tor_log2(65),==, 6); tt_int_op(tor_log2(65),==, 6);
tt_int_op(tor_log2(63),==, 5); tt_int_op(tor_log2(63),==, 5);
@ -1395,13 +1404,14 @@ thread_test_func_(void* _s)
/** Run unit tests for threading logic. */ /** Run unit tests for threading logic. */
static void static void
test_util_threads(void) test_util_threads(void *arg)
{ {
char *s1 = NULL, *s2 = NULL; char *s1 = NULL, *s2 = NULL;
int done = 0, timedout = 0; int done = 0, timedout = 0;
time_t started; time_t started;
#ifndef _WIN32 #ifndef _WIN32
struct timeval tv; struct timeval tv;
(void)arg;
tv.tv_sec=0; tv.tv_sec=0;
tv.tv_usec=100*1000; tv.tv_usec=100*1000;
#endif #endif
@ -1470,13 +1480,14 @@ test_util_threads(void)
/** Run unit tests for compression functions */ /** Run unit tests for compression functions */
static void static void
test_util_gzip(void) test_util_gzip(void *arg)
{ {
char *buf1=NULL, *buf2=NULL, *buf3=NULL, *cp1, *cp2; char *buf1=NULL, *buf2=NULL, *buf3=NULL, *cp1, *cp2;
const char *ccp2; const char *ccp2;
size_t len1, len2; size_t len1, len2;
tor_zlib_state_t *state = NULL; tor_zlib_state_t *state = NULL;
(void)arg;
buf1 = tor_strdup("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAAAAAAAAAAAAAAAAZ"); buf1 = tor_strdup("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAAAAAAAAAAAAAAAAZ");
tt_assert(detect_compression_method(buf1, strlen(buf1)) == UNKNOWN_METHOD); tt_assert(detect_compression_method(buf1, strlen(buf1)) == UNKNOWN_METHOD);
if (is_gzip_supported()) { if (is_gzip_supported()) {
@ -1579,7 +1590,7 @@ test_util_gzip(void)
/** Run unit tests for mmap() wrapper functionality. */ /** Run unit tests for mmap() wrapper functionality. */
static void static void
test_util_mmap(void) test_util_mmap(void *arg)
{ {
char *fname1 = tor_strdup(get_fname("mapped_1")); char *fname1 = tor_strdup(get_fname("mapped_1"));
char *fname2 = tor_strdup(get_fname("mapped_2")); char *fname2 = tor_strdup(get_fname("mapped_2"));
@ -1588,6 +1599,7 @@ test_util_mmap(void)
char *buf = tor_malloc(17000); char *buf = tor_malloc(17000);
tor_mmap_t *mapping = NULL; tor_mmap_t *mapping = NULL;
(void)arg;
crypto_rand(buf, buflen); crypto_rand(buf, buflen);
mapping = tor_mmap_file(fname1); mapping = tor_mmap_file(fname1);
@ -1655,13 +1667,14 @@ test_util_mmap(void)
/** Run unit tests for escaping/unescaping data for use by controllers. */ /** Run unit tests for escaping/unescaping data for use by controllers. */
static void static void
test_util_control_formats(void) test_util_control_formats(void *arg)
{ {
char *out = NULL; char *out = NULL;
const char *inp = const char *inp =
"..This is a test\r\n.of the emergency \n..system.\r\n\rZ.\r\n"; "..This is a test\r\n.of the emergency \n..system.\r\n\rZ.\r\n";
size_t sz; size_t sz;
(void)arg;
sz = read_escaped_data(inp, strlen(inp), &out); sz = read_escaped_data(inp, strlen(inp), &out);
tt_str_op(out,==, tt_str_op(out,==,
".This is a test\nof the emergency \n.system.\n\rZ.\n"); ".This is a test\nof the emergency \n.system.\n\rZ.\n");
@ -1685,7 +1698,7 @@ test_util_control_formats(void)
} while (0) } while (0)
static void static void
test_util_sscanf(void) test_util_sscanf(void *arg)
{ {
unsigned u1, u2, u3; unsigned u1, u2, u3;
unsigned long ulng; unsigned long ulng;
@ -1696,6 +1709,7 @@ test_util_sscanf(void)
double d1,d2,d3,d4; double d1,d2,d3,d4;
/* Simple tests (malformed patterns, literal matching, ...) */ /* Simple tests (malformed patterns, literal matching, ...) */
(void)arg;
tt_int_op(-1,==, tor_sscanf("123", "%i", &r)); /* %i is not supported */ tt_int_op(-1,==, tor_sscanf("123", "%i", &r)); /* %i is not supported */
tt_int_op(-1,==, tor_sscanf("wrong", "%5c", s1)); /* %c cannot have a number. */ tt_int_op(-1,==, tor_sscanf("wrong", "%5c", s1)); /* %c cannot have a number. */
tt_int_op(-1,==, tor_sscanf("hello", "%s", s1)); /* %s needs a number. */ tt_int_op(-1,==, tor_sscanf("hello", "%s", s1)); /* %s needs a number. */
@ -2026,9 +2040,10 @@ test_util_sscanf(void)
} }
static void static void
test_util_path_is_relative(void) test_util_path_is_relative(void *arg)
{ {
/* OS-independent tests */ /* OS-independent tests */
(void)arg;
tt_int_op(1,==, path_is_relative("")); tt_int_op(1,==, path_is_relative(""));
tt_int_op(1,==, path_is_relative("dir")); tt_int_op(1,==, path_is_relative("dir"));
tt_int_op(1,==, path_is_relative("dir/")); tt_int_op(1,==, path_is_relative("dir/"));
@ -2063,12 +2078,13 @@ test_util_path_is_relative(void)
/** Run unittests for memory pool allocator */ /** Run unittests for memory pool allocator */
static void static void
test_util_mempool(void) test_util_mempool(void *arg)
{ {
mp_pool_t *pool = NULL; mp_pool_t *pool = NULL;
smartlist_t *allocated = NULL; smartlist_t *allocated = NULL;
int i; int i;
(void)arg;
pool = mp_pool_new(1, 100); pool = mp_pool_new(1, 100);
tt_assert(pool); tt_assert(pool);
tt_assert(pool->new_chunk_capacity >= 100); tt_assert(pool->new_chunk_capacity >= 100);
@ -2123,13 +2139,14 @@ test_util_mempool(void)
/** Run unittests for memory area allocator */ /** Run unittests for memory area allocator */
static void static void
test_util_memarea(void) test_util_memarea(void *arg)
{ {
memarea_t *area = memarea_new(); memarea_t *area = memarea_new();
char *p1, *p2, *p3, *p1_orig; char *p1, *p2, *p3, *p1_orig;
void *malloced_ptr = NULL; void *malloced_ptr = NULL;
int i; int i;
(void)arg;
tt_assert(area); tt_assert(area);
p1_orig = p1 = memarea_alloc(area,64); p1_orig = p1 = memarea_alloc(area,64);
@ -2220,12 +2237,13 @@ test_util_memarea(void)
/** Run unit tests for utility functions to get file names relative to /** Run unit tests for utility functions to get file names relative to
* the data directory. */ * the data directory. */
static void static void
test_util_datadir(void) test_util_datadir(void *arg)
{ {
char buf[1024]; char buf[1024];
char *f = NULL; char *f = NULL;
char *temp_dir = NULL; char *temp_dir = NULL;
(void)arg;
temp_dir = get_datadir_fname(NULL); temp_dir = get_datadir_fname(NULL);
f = get_datadir_fname("state"); f = get_datadir_fname("state");
tor_snprintf(buf, sizeof(buf), "%s"PATH_SEPARATOR"state", temp_dir); tor_snprintf(buf, sizeof(buf), "%s"PATH_SEPARATOR"state", temp_dir);
@ -2252,13 +2270,14 @@ test_util_datadir(void)
} }
static void static void
test_util_strtok(void) test_util_strtok(void *arg)
{ {
char buf[128]; char buf[128];
char buf2[128]; char buf2[128];
int i; int i;
char *cp1, *cp2; char *cp1, *cp2;
(void)arg;
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
const char *pad1="", *pad2=""; const char *pad1="", *pad2="";
switch (i) { switch (i) {
@ -3314,7 +3333,7 @@ test_util_split_lines(void *ptr)
} }
static void static void
test_util_di_ops(void) test_util_di_ops(void *arg)
{ {
#define LT -1 #define LT -1
#define GT 1 #define GT 1
@ -3334,6 +3353,7 @@ test_util_di_ops(void)
int i; int i;
(void)arg;
for (i = 0; examples[i].a; ++i) { for (i = 0; examples[i].a; ++i) {
size_t len = strlen(examples[i].a); size_t len = strlen(examples[i].a);
int eq1, eq2, neq1, neq2, cmp1, cmp2; int eq1, eq2, neq1, neq2, cmp1, cmp2;
@ -3859,7 +3879,7 @@ test_util_strclear(void *arg)
} }
#define UTIL_LEGACY(name) \ #define UTIL_LEGACY(name) \
{ #name, legacy_test_helper, 0, &legacy_setup, test_util_ ## name } { #name, test_util_ ## name , 0, NULL, NULL }
#define UTIL_TEST(name, flags) \ #define UTIL_TEST(name, flags) \
{ #name, test_util_ ## name, flags, NULL, NULL } { #name, test_util_ ## name, flags, NULL, NULL }