mirror of
https://gitlab.torproject.org/tpo/core/tor.git
synced 2024-11-24 04:13:28 +01:00
Remove the legacy_test_helper and legacy_setup wrappers
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
parent
c72a94ea1c
commit
a6627fdb80
@ -232,7 +232,7 @@ free_pregenerated_keys(void)
|
||||
|
||||
/** Run unit tests for the onion handshake code. */
|
||||
static void
|
||||
test_onion_handshake(void)
|
||||
test_onion_handshake(void *arg)
|
||||
{
|
||||
/* client-side */
|
||||
crypto_dh_t *c_dh = NULL;
|
||||
@ -245,6 +245,7 @@ test_onion_handshake(void)
|
||||
/* shared */
|
||||
crypto_pk_t *pk = NULL, *pk2 = NULL;
|
||||
|
||||
(void)arg;
|
||||
pk = pk_generate(0);
|
||||
pk2 = pk_generate(1);
|
||||
|
||||
@ -420,7 +421,7 @@ test_ntor_handshake(void *arg)
|
||||
|
||||
/** Run unit tests for the onion queues. */
|
||||
static void
|
||||
test_onion_queues(void)
|
||||
test_onion_queues(void *arg)
|
||||
{
|
||||
uint8_t buf1[TAP_ONIONSKIN_CHALLENGE_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 *create1 = 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 */
|
||||
|
||||
create_cell_init(create1, CELL_CREATE, ONION_HANDSHAKE_TYPE_TAP,
|
||||
@ -466,7 +468,7 @@ test_onion_queues(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_circuit_timeout(void)
|
||||
test_circuit_timeout(void *arg)
|
||||
{
|
||||
/* Plan:
|
||||
* 1. Generate 1000 samples
|
||||
@ -484,6 +486,7 @@ test_circuit_timeout(void)
|
||||
or_state_t *state=NULL;
|
||||
int i, runs;
|
||||
double close_ms;
|
||||
(void)arg;
|
||||
circuit_build_times_init(&initial);
|
||||
circuit_build_times_init(&estimate);
|
||||
circuit_build_times_init(&final);
|
||||
@ -619,7 +622,7 @@ test_circuit_timeout(void)
|
||||
|
||||
/** Test encoding and parsing of rendezvous service descriptors. */
|
||||
static void
|
||||
test_rend_fns(void)
|
||||
test_rend_fns(void *arg)
|
||||
{
|
||||
rend_service_descriptor_t *generated = NULL, *parsed = NULL;
|
||||
char service_id[DIGEST_LEN];
|
||||
@ -642,6 +645,7 @@ test_rend_fns(void)
|
||||
char address6[] = "foo.bar.abcdefghijklmnop.onion";
|
||||
char address7[] = ".abcdefghijklmnop.onion";
|
||||
|
||||
(void)arg;
|
||||
tt_assert(BAD_HOSTNAME == parse_extended_hostname(address1));
|
||||
tt_assert(ONION_HOSTNAME == parse_extended_hostname(address2));
|
||||
tt_str_op(address2,==, "aaaaaaaaaaaaaaaa");
|
||||
@ -771,7 +775,7 @@ test_rend_fns(void)
|
||||
|
||||
/** Run unit tests for GeoIP code. */
|
||||
static void
|
||||
test_geoip(void)
|
||||
test_geoip(void *arg)
|
||||
{
|
||||
int i, j;
|
||||
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
|
||||
* '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));
|
||||
@ -1017,7 +1022,7 @@ test_geoip(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 */
|
||||
char *s = NULL;
|
||||
@ -1025,6 +1030,7 @@ test_geoip_with_pt(void)
|
||||
tor_addr_t addr;
|
||||
struct in6_addr in6;
|
||||
|
||||
(void)arg;
|
||||
get_options_mutable()->BridgeRelay = 1;
|
||||
get_options_mutable()->BridgeRecordUsageByCountry = 1;
|
||||
|
||||
@ -1093,7 +1099,7 @@ test_geoip_with_pt(void)
|
||||
|
||||
/** Run unit tests for stats code. */
|
||||
static void
|
||||
test_stats(void)
|
||||
test_stats(void *arg)
|
||||
{
|
||||
time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */
|
||||
char *s = NULL;
|
||||
@ -1101,6 +1107,7 @@ test_stats(void)
|
||||
|
||||
/* Start with testing exit port statistics; we shouldn't collect exit
|
||||
* stats without initializing them. */
|
||||
(void)arg;
|
||||
rep_hist_note_exit_stream_opened(80);
|
||||
rep_hist_note_exit_bytes(80, 100, 10000);
|
||||
s = rep_hist_format_exit_stats(now + 86400);
|
||||
@ -1250,35 +1257,10 @@ test_stats(void)
|
||||
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) \
|
||||
{ #name, legacy_test_helper, 0, &legacy_setup, test_ ## name }
|
||||
{ #name, test_ ## name , 0, NULL, NULL }
|
||||
#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[] = {
|
||||
ENT(onion_handshake),
|
||||
|
||||
@ -66,9 +66,6 @@
|
||||
const char *get_fname(const char *name);
|
||||
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 US_CONCAT_2__(a, b) a ## _ ## b
|
||||
#define US_CONCAT_3__(a, b, c) a ## _ ## b ## _ ## c
|
||||
|
||||
@ -10,13 +10,14 @@
|
||||
#include "addressmap.h"
|
||||
|
||||
static void
|
||||
test_addr_basic(void)
|
||||
test_addr_basic(void *arg)
|
||||
{
|
||||
uint32_t u32;
|
||||
uint16_t u16;
|
||||
char *cp;
|
||||
|
||||
/* Test addr_port_lookup */
|
||||
(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");
|
||||
@ -179,7 +180,7 @@ test_addr_basic(void)
|
||||
|
||||
/** Run unit tests for IPv6 encoding/decoding/manipulation functions. */
|
||||
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 rbuf[REVERSE_LOOKUP_NAME_BUF_LEN];
|
||||
@ -194,6 +195,7 @@ test_addr_ip6_helpers(void)
|
||||
struct sockaddr_in6 *sin6;
|
||||
|
||||
/* Test tor_inet_ntop and tor_inet_pton: IPv6 */
|
||||
(void)arg;
|
||||
{
|
||||
const char *ip = "2001::1234";
|
||||
const char *ip_ffff = "::ffff:192.168.1.2";
|
||||
@ -736,7 +738,7 @@ test_addr_ip6_helpers(void)
|
||||
|
||||
/** Test tor_addr_port_parse(). */
|
||||
static void
|
||||
test_addr_parse(void)
|
||||
test_addr_parse(void *arg)
|
||||
{
|
||||
int r;
|
||||
tor_addr_t addr;
|
||||
@ -744,6 +746,7 @@ test_addr_parse(void)
|
||||
uint16_t port = 0;
|
||||
|
||||
/* Correct call. */
|
||||
(void)arg;
|
||||
r= tor_addr_port_parse(LOG_DEBUG,
|
||||
"192.0.2.1:1234",
|
||||
&addr, &port, -1);
|
||||
@ -1047,7 +1050,7 @@ test_addr_make_null(void *data)
|
||||
}
|
||||
|
||||
#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[] = {
|
||||
ADDR_LEGACY(basic),
|
||||
|
||||
@ -37,7 +37,7 @@ compare_without_first_ch_(const void *a, const void **b)
|
||||
|
||||
/** Run unit tests for basic dynamic-sized array functionality. */
|
||||
static void
|
||||
test_container_smartlist_basic(void)
|
||||
test_container_smartlist_basic(void *arg)
|
||||
{
|
||||
smartlist_t *sl;
|
||||
char *v0 = tor_strdup("v0");
|
||||
@ -52,6 +52,7 @@ test_container_smartlist_basic(void)
|
||||
/* XXXX test sort_digests, uniq_strings, uniq_digests */
|
||||
|
||||
/* Test smartlist add, del_keeporder, insert, get. */
|
||||
(void)arg;
|
||||
sl = smartlist_new();
|
||||
smartlist_add(sl, v1);
|
||||
smartlist_add(sl, v2);
|
||||
@ -92,13 +93,14 @@ test_container_smartlist_basic(void)
|
||||
|
||||
/** Run unit tests for smartlist-of-strings functionality. */
|
||||
static void
|
||||
test_container_smartlist_strings(void)
|
||||
test_container_smartlist_strings(void *arg)
|
||||
{
|
||||
smartlist_t *sl = smartlist_new();
|
||||
char *cp=NULL, *cp_alloc=NULL;
|
||||
size_t sz;
|
||||
|
||||
/* Test split and join */
|
||||
(void)arg;
|
||||
tt_int_op(0,==, smartlist_len(sl));
|
||||
smartlist_split_string(sl, "abc", ":", 0, 0);
|
||||
tt_int_op(1,==, smartlist_len(sl));
|
||||
@ -349,7 +351,7 @@ test_container_smartlist_strings(void)
|
||||
|
||||
/** Run unit tests for smartlist set manipulation functions. */
|
||||
static void
|
||||
test_container_smartlist_overlap(void)
|
||||
test_container_smartlist_overlap(void *arg)
|
||||
{
|
||||
smartlist_t *sl = smartlist_new();
|
||||
smartlist_t *ints = smartlist_new();
|
||||
@ -357,6 +359,7 @@ test_container_smartlist_overlap(void)
|
||||
smartlist_t *evens = smartlist_new();
|
||||
smartlist_t *primes = smartlist_new();
|
||||
int i;
|
||||
(void)arg;
|
||||
for (i=1; i < 10; i += 2)
|
||||
smartlist_add(odds, (void*)(uintptr_t)i);
|
||||
for (i=0; i < 10; i += 2)
|
||||
@ -402,11 +405,12 @@ test_container_smartlist_overlap(void)
|
||||
|
||||
/** Run unit tests for smartlist-of-digests functions. */
|
||||
static void
|
||||
test_container_smartlist_digests(void)
|
||||
test_container_smartlist_digests(void *arg)
|
||||
{
|
||||
smartlist_t *sl = smartlist_new();
|
||||
|
||||
/* contains_digest */
|
||||
(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));
|
||||
@ -435,13 +439,14 @@ test_container_smartlist_digests(void)
|
||||
|
||||
/** Run unit tests for concatenate-a-smartlist-of-strings functions. */
|
||||
static void
|
||||
test_container_smartlist_join(void)
|
||||
test_container_smartlist_join(void *arg)
|
||||
{
|
||||
smartlist_t *sl = smartlist_new();
|
||||
smartlist_t *sl2 = smartlist_new(), *sl3 = smartlist_new(),
|
||||
*sl4 = smartlist_new();
|
||||
char *joined=NULL;
|
||||
/* unique, sorted. */
|
||||
(void)arg;
|
||||
smartlist_split_string(sl,
|
||||
"Abashments Ambush Anchorman Bacon Banks Borscht "
|
||||
"Bunks Inhumane Insurance Knish Know Manners "
|
||||
@ -532,11 +537,12 @@ test_container_smartlist_ints_eq(void *arg)
|
||||
|
||||
/** Run unit tests for bitarray code */
|
||||
static void
|
||||
test_container_bitarray(void)
|
||||
test_container_bitarray(void *arg)
|
||||
{
|
||||
bitarray_t *ba = NULL;
|
||||
int i, j, ok=1;
|
||||
|
||||
(void)arg;
|
||||
ba = bitarray_init_zero(1);
|
||||
tt_assert(ba);
|
||||
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
|
||||
* bloom filter) */
|
||||
static void
|
||||
test_container_digestset(void)
|
||||
test_container_digestset(void *arg)
|
||||
{
|
||||
smartlist_t *included = smartlist_new();
|
||||
char d[DIGEST_LEN];
|
||||
@ -584,6 +590,7 @@ test_container_digestset(void)
|
||||
int false_positives = 0;
|
||||
digestset_t *set = NULL;
|
||||
|
||||
(void)arg;
|
||||
for (i = 0; i < 1000; ++i) {
|
||||
crypto_rand(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. */
|
||||
static void
|
||||
test_container_pqueue(void)
|
||||
test_container_pqueue(void *arg)
|
||||
{
|
||||
smartlist_t *sl = smartlist_new();
|
||||
int (*cmp)(const void *, const void*);
|
||||
@ -650,6 +657,8 @@ test_container_pqueue(void)
|
||||
|
||||
#define OK() smartlist_pqueue_assert_ok(sl, cmp, offset)
|
||||
|
||||
(void)arg;
|
||||
|
||||
cmp = compare_strings_for_pqueue_;
|
||||
smartlist_pqueue_add(sl, cmp, offset, &cows);
|
||||
smartlist_pqueue_add(sl, cmp, offset, &zebras);
|
||||
@ -725,7 +734,7 @@ test_container_pqueue(void)
|
||||
|
||||
/** Run unit tests for string-to-void* map functions */
|
||||
static void
|
||||
test_container_strmap(void)
|
||||
test_container_strmap(void *arg)
|
||||
{
|
||||
strmap_t *map;
|
||||
strmap_iter_t *iter;
|
||||
@ -742,6 +751,7 @@ test_container_strmap(void)
|
||||
char *v104 = tor_strdup("v104");
|
||||
char *v105 = tor_strdup("v105");
|
||||
|
||||
(void)arg;
|
||||
map = strmap_new();
|
||||
tt_assert(map);
|
||||
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. */
|
||||
static void
|
||||
test_container_order_functions(void)
|
||||
test_container_order_functions(void *arg)
|
||||
{
|
||||
int lst[25], n = 0;
|
||||
unsigned int lst2[25];
|
||||
@ -840,6 +850,7 @@ test_container_order_functions(void)
|
||||
|
||||
#define median() median_int(lst, n)
|
||||
|
||||
(void)arg;
|
||||
lst[n++] = 12;
|
||||
tt_int_op(12,==, median()); /* 12 */
|
||||
lst[n++] = 77;
|
||||
@ -929,7 +940,7 @@ test_container_di_map(void *arg)
|
||||
|
||||
/** Run unit tests for fp_pair-to-void* map functions */
|
||||
static void
|
||||
test_container_fp_pair_map(void)
|
||||
test_container_fp_pair_map(void *arg)
|
||||
{
|
||||
fp_pair_map_t *map;
|
||||
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 *v105 = tor_strdup("v105");
|
||||
|
||||
(void)arg;
|
||||
map = fp_pair_map_new();
|
||||
tt_assert(map);
|
||||
tt_int_op(fp_pair_map_size(map),==, 0);
|
||||
@ -1024,7 +1036,7 @@ test_container_fp_pair_map(void)
|
||||
}
|
||||
|
||||
#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) \
|
||||
{ #name, test_container_ ## name, (flags), NULL, NULL }
|
||||
|
||||
@ -20,7 +20,7 @@ extern const char AUTHORITY_SIGNKEY_A_DIGEST256[];
|
||||
|
||||
/** Run unit tests for Diffie-Hellman functionality. */
|
||||
static void
|
||||
test_crypto_dh(void)
|
||||
test_crypto_dh(void *arg)
|
||||
{
|
||||
crypto_dh_t *dh1 = 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];
|
||||
ssize_t s1len, s2len;
|
||||
|
||||
(void)arg;
|
||||
tt_int_op(crypto_dh_get_bytes(dh1),==, DH_BYTES);
|
||||
tt_int_op(crypto_dh_get_bytes(dh2),==, DH_BYTES);
|
||||
|
||||
@ -63,13 +64,14 @@ test_crypto_dh(void)
|
||||
/** Run unit tests for our random number generation function and its wrappers.
|
||||
*/
|
||||
static void
|
||||
test_crypto_rng(void)
|
||||
test_crypto_rng(void *arg)
|
||||
{
|
||||
int i, j, allok;
|
||||
char data1[100], data2[100];
|
||||
double d;
|
||||
|
||||
/* Try out RNG. */
|
||||
(void)arg;
|
||||
tt_assert(! crypto_seed_rng(0));
|
||||
crypto_rand(data1, 100);
|
||||
crypto_rand(data2, 100);
|
||||
@ -252,7 +254,7 @@ test_crypto_aes(void *arg)
|
||||
|
||||
/** Run unit tests for our SHA-1 functionality */
|
||||
static void
|
||||
test_crypto_sha(void)
|
||||
test_crypto_sha(void *arg)
|
||||
{
|
||||
crypto_digest_t *d1 = NULL, *d2 = NULL;
|
||||
int i;
|
||||
@ -263,6 +265,7 @@ test_crypto_sha(void)
|
||||
char *mem_op_hex_tmp=NULL;
|
||||
|
||||
/* Test SHA-1 with a test vector from the specification. */
|
||||
(void)arg;
|
||||
i = crypto_digest(data, "abc", 3);
|
||||
test_memeq_hex(data, "A9993E364706816ABA3E25717850C26C9CD0D89D");
|
||||
tt_int_op(i, ==, 0);
|
||||
@ -392,7 +395,7 @@ test_crypto_sha(void)
|
||||
|
||||
/** Run unit tests for our public key crypto functions */
|
||||
static void
|
||||
test_crypto_pk(void)
|
||||
test_crypto_pk(void *arg)
|
||||
{
|
||||
crypto_pk_t *pk1 = NULL, *pk2 = NULL;
|
||||
char *encoded = NULL;
|
||||
@ -401,6 +404,7 @@ test_crypto_pk(void)
|
||||
int i, len;
|
||||
|
||||
/* Public-key ciphers */
|
||||
(void)arg;
|
||||
pk1 = pk_generate(0);
|
||||
pk2 = crypto_pk_new();
|
||||
tt_assert(pk1 && pk2);
|
||||
@ -561,13 +565,14 @@ test_crypto_pk_fingerprints(void *arg)
|
||||
|
||||
/** Sanity check for crypto pk digests */
|
||||
static void
|
||||
test_crypto_digests(void)
|
||||
test_crypto_digests(void *arg)
|
||||
{
|
||||
crypto_pk_t *k = NULL;
|
||||
ssize_t r;
|
||||
digests_t pkey_digests;
|
||||
char digest[DIGEST_LEN];
|
||||
|
||||
(void)arg;
|
||||
k = crypto_pk_new();
|
||||
tt_assert(k);
|
||||
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,
|
||||
* fingerprints, etc) */
|
||||
static void
|
||||
test_crypto_formats(void)
|
||||
test_crypto_formats(void *arg)
|
||||
{
|
||||
char *data1 = NULL, *data2 = NULL, *data3 = NULL;
|
||||
int i, j, idx;
|
||||
|
||||
(void)arg;
|
||||
data1 = tor_malloc(1024);
|
||||
data2 = 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. */
|
||||
static void
|
||||
test_crypto_s2k(void)
|
||||
test_crypto_s2k(void *arg)
|
||||
{
|
||||
char buf[29];
|
||||
char buf2[29];
|
||||
char *buf3 = NULL;
|
||||
int i;
|
||||
|
||||
(void)arg;
|
||||
memset(buf, 0, sizeof(buf));
|
||||
memset(buf2, 0, sizeof(buf2));
|
||||
buf3 = tor_malloc(65536);
|
||||
@ -842,10 +849,11 @@ test_crypto_aes_iv(void *arg)
|
||||
|
||||
/** Test base32 decoding. */
|
||||
static void
|
||||
test_crypto_base32_decode(void)
|
||||
test_crypto_base32_decode(void *arg)
|
||||
{
|
||||
char plain[60], encoded[96 + 1], decoded[60];
|
||||
int res;
|
||||
(void)arg;
|
||||
crypto_rand(plain, 60);
|
||||
/* Encode and decode a random string. */
|
||||
base32_encode(encoded, 96 + 1, plain, 60);
|
||||
@ -1276,7 +1284,7 @@ static const struct testcase_setup_t pass_data = {
|
||||
};
|
||||
|
||||
#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[] = {
|
||||
CRYPTO_LEGACY(formats),
|
||||
|
||||
@ -25,8 +25,9 @@
|
||||
#include "test.h"
|
||||
|
||||
static void
|
||||
test_dir_nicknames(void)
|
||||
test_dir_nicknames(void *arg)
|
||||
{
|
||||
(void)arg;
|
||||
tt_assert( is_legal_nickname("a"));
|
||||
tt_assert(!is_legal_nickname(""));
|
||||
tt_assert(!is_legal_nickname("abcdefghijklmnopqrst")); /* 20 chars */
|
||||
@ -73,7 +74,7 @@ test_dir_nicknames(void)
|
||||
|
||||
/** Run unit tests for router descriptor generation logic. */
|
||||
static void
|
||||
test_dir_formats(void)
|
||||
test_dir_formats(void *arg)
|
||||
{
|
||||
char *buf = NULL;
|
||||
char buf2[8192];
|
||||
@ -89,6 +90,7 @@ test_dir_formats(void)
|
||||
or_options_t *options = get_options_mutable();
|
||||
const addr_policy_t *p;
|
||||
|
||||
(void)arg;
|
||||
pk1 = pk_generate(0);
|
||||
pk2 = pk_generate(1);
|
||||
|
||||
@ -293,11 +295,12 @@ test_dir_formats(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_dir_versions(void)
|
||||
test_dir_versions(void *arg)
|
||||
{
|
||||
tor_version_t ver1;
|
||||
|
||||
/* Try out version parsing functionality */
|
||||
(void)arg;
|
||||
tt_int_op(0,==, tor_version_parse("0.3.4pre2-cvs", &ver1));
|
||||
tt_int_op(0,==, ver1.major);
|
||||
tt_int_op(3,==, ver1.minor);
|
||||
@ -410,11 +413,12 @@ test_dir_versions(void)
|
||||
|
||||
/** Run unit tests for directory fp_pair functions. */
|
||||
static void
|
||||
test_dir_fp_pairs(void)
|
||||
test_dir_fp_pairs(void *arg)
|
||||
{
|
||||
smartlist_t *sl = smartlist_new();
|
||||
fp_pair_t *pair;
|
||||
|
||||
(void)arg;
|
||||
dir_split_resource_into_fingerprint_pairs(
|
||||
/* Two pairs, out of order, with one duplicate. */
|
||||
"73656372657420646174612E0000000000FFFFFF-"
|
||||
@ -557,7 +561,7 @@ test_dir_split_fps(void *testdata)
|
||||
}
|
||||
|
||||
static void
|
||||
test_dir_measured_bw_kb(void)
|
||||
test_dir_measured_bw_kb(void *arg)
|
||||
{
|
||||
measured_bw_line_t mbwl;
|
||||
int i;
|
||||
@ -605,6 +609,7 @@ test_dir_measured_bw_kb(void)
|
||||
"end"
|
||||
};
|
||||
|
||||
(void)arg;
|
||||
for (i = 0; strcmp(lines_fail[i], "end"); i++) {
|
||||
//fprintf(stderr, "Testing: %s\n", lines_fail[i]);
|
||||
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 */
|
||||
static void
|
||||
test_dir_measured_bw_kb_cache(void)
|
||||
test_dir_measured_bw_kb_cache(void *arg)
|
||||
{
|
||||
/* Initial fake time_t for testing */
|
||||
time_t curr = MBWC_INIT_TIME;
|
||||
@ -637,6 +642,7 @@ test_dir_measured_bw_kb_cache(void)
|
||||
time_t as_of;
|
||||
|
||||
/* First, clear the cache and assert that it's empty */
|
||||
(void)arg;
|
||||
dirserv_clear_measured_bw_cache();
|
||||
tt_int_op(dirserv_get_measured_bw_cache_size(),==, 0);
|
||||
/*
|
||||
@ -700,7 +706,7 @@ test_dir_measured_bw_kb_cache(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_dir_param_voting(void)
|
||||
test_dir_param_voting(void *arg)
|
||||
{
|
||||
networkstatus_t vote1, vote2, vote3, vote4;
|
||||
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,
|
||||
so that's all we need to set.
|
||||
*/
|
||||
(void)arg;
|
||||
memset(&vote1, 0, sizeof(vote1));
|
||||
memset(&vote2, 0, sizeof(vote2));
|
||||
memset(&vote3, 0, sizeof(vote3));
|
||||
@ -1693,8 +1700,9 @@ test_a_networkstatus(
|
||||
/** Run unit tests for generating and parsing V3 consensus networkstatus
|
||||
* documents. */
|
||||
static void
|
||||
test_dir_v3_networkstatus(void)
|
||||
test_dir_v3_networkstatus(void *arg)
|
||||
{
|
||||
(void)arg;
|
||||
test_a_networkstatus(gen_routerstatus_for_v3ns,
|
||||
vote_tweaks_for_v3ns,
|
||||
test_vrs_for_v3ns,
|
||||
@ -2238,9 +2246,10 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now)
|
||||
*/
|
||||
|
||||
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 */
|
||||
(void)arg;
|
||||
alternate_clip_bw = 0;
|
||||
test_a_networkstatus(gen_routerstatus_for_umbw,
|
||||
vote_tweaks_for_umbw,
|
||||
@ -2255,7 +2264,7 @@ test_dir_clip_unmeasured_bw_kb(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
|
||||
@ -2263,6 +2272,7 @@ test_dir_clip_unmeasured_bw_kb_alt(void)
|
||||
* DEFAULT_MAX_UNMEASURED_BW_KB and if the consensus incorrectly uses that
|
||||
* cutoff it will fail the test.
|
||||
*/
|
||||
(void)arg;
|
||||
alternate_clip_bw = 3 * DEFAULT_MAX_UNMEASURED_BW_KB;
|
||||
test_a_networkstatus(gen_routerstatus_for_umbw,
|
||||
vote_tweaks_for_umbw,
|
||||
@ -2374,7 +2384,7 @@ test_dir_http_handling(void *args)
|
||||
}
|
||||
|
||||
#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) \
|
||||
{ #name, test_dir_##name, (flags), NULL, NULL }
|
||||
|
||||
@ -394,8 +394,9 @@ make_intro_from_plaintext(
|
||||
*/
|
||||
|
||||
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));
|
||||
}
|
||||
|
||||
@ -403,8 +404,9 @@ test_introduce_decrypt_v0(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));
|
||||
}
|
||||
|
||||
@ -412,8 +414,9 @@ test_introduce_decrypt_v1(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));
|
||||
}
|
||||
|
||||
@ -421,8 +424,9 @@ test_introduce_decrypt_v2(void)
|
||||
*/
|
||||
|
||||
static void
|
||||
test_introduce_decrypt_v3(void)
|
||||
test_introduce_decrypt_v3(void *arg)
|
||||
{
|
||||
(void)arg;
|
||||
do_decrypt_test(
|
||||
v3_no_auth_test_plaintext, sizeof(v3_no_auth_test_plaintext));
|
||||
do_decrypt_test(
|
||||
@ -433,8 +437,9 @@ test_introduce_decrypt_v3(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));
|
||||
}
|
||||
|
||||
@ -442,8 +447,9 @@ test_introduce_early_parse_v0(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));
|
||||
}
|
||||
|
||||
@ -451,8 +457,9 @@ test_introduce_early_parse_v1(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));
|
||||
}
|
||||
|
||||
@ -460,8 +467,9 @@ test_introduce_early_parse_v2(void)
|
||||
*/
|
||||
|
||||
static void
|
||||
test_introduce_early_parse_v3(void)
|
||||
test_introduce_early_parse_v3(void *arg)
|
||||
{
|
||||
(void)arg;
|
||||
do_early_parse_test(
|
||||
v3_no_auth_test_plaintext, sizeof(v3_no_auth_test_plaintext));
|
||||
do_early_parse_test(
|
||||
@ -472,8 +480,9 @@ test_introduce_early_parse_v3(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));
|
||||
}
|
||||
|
||||
@ -481,8 +490,9 @@ test_introduce_late_parse_v0(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));
|
||||
}
|
||||
|
||||
@ -490,8 +500,9 @@ test_introduce_late_parse_v1(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));
|
||||
}
|
||||
|
||||
@ -499,8 +510,9 @@ test_introduce_late_parse_v2(void)
|
||||
*/
|
||||
|
||||
static void
|
||||
test_introduce_late_parse_v3(void)
|
||||
test_introduce_late_parse_v3(void *arg)
|
||||
{
|
||||
(void)arg;
|
||||
do_late_parse_test(
|
||||
v3_no_auth_test_plaintext, sizeof(v3_no_auth_test_plaintext));
|
||||
do_late_parse_test(
|
||||
@ -508,7 +520,7 @@ test_introduce_late_parse_v3(void)
|
||||
}
|
||||
|
||||
#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[] = {
|
||||
INTRODUCE_LEGACY(early_parse_v0),
|
||||
|
||||
@ -27,13 +27,14 @@ reset_mp(managed_proxy_t *mp)
|
||||
}
|
||||
|
||||
static void
|
||||
test_pt_parsing(void)
|
||||
test_pt_parsing(void *arg)
|
||||
{
|
||||
char line[200];
|
||||
transport_t *transport = NULL;
|
||||
tor_addr_t test_addr;
|
||||
|
||||
managed_proxy_t *mp = tor_malloc_zero(sizeof(managed_proxy_t));
|
||||
(void)arg;
|
||||
mp->conf_state = PT_PROTO_INFANT;
|
||||
mp->transports = smartlist_new();
|
||||
|
||||
@ -187,11 +188,12 @@ test_pt_get_transport_options(void *arg)
|
||||
}
|
||||
|
||||
static void
|
||||
test_pt_protocol(void)
|
||||
test_pt_protocol(void *arg)
|
||||
{
|
||||
char line[200];
|
||||
|
||||
managed_proxy_t *mp = tor_malloc_zero(sizeof(managed_proxy_t));
|
||||
(void)arg;
|
||||
mp->conf_state = PT_PROTO_LAUNCHED;
|
||||
mp->transports = smartlist_new();
|
||||
mp->argv = tor_calloc(sizeof(char *), 2);
|
||||
@ -529,7 +531,7 @@ test_get_pt_proxy_uri(void *arg)
|
||||
}
|
||||
|
||||
#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[] = {
|
||||
PT_LEGACY(parsing),
|
||||
|
||||
@ -18,10 +18,11 @@ static const char *test_buffer =
|
||||
" mollit anim id est laborum.";
|
||||
|
||||
static void
|
||||
test_replaycache_alloc(void)
|
||||
test_replaycache_alloc(void *arg)
|
||||
{
|
||||
replaycache_t *r = NULL;
|
||||
|
||||
(void)arg;
|
||||
r = replaycache_new(600, 300);
|
||||
tt_assert(r != NULL);
|
||||
|
||||
@ -32,11 +33,12 @@ test_replaycache_alloc(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_replaycache_badalloc(void)
|
||||
test_replaycache_badalloc(void *arg)
|
||||
{
|
||||
replaycache_t *r = NULL;
|
||||
|
||||
/* Negative horizon should fail */
|
||||
(void)arg;
|
||||
r = replaycache_new(-600, 300);
|
||||
tt_assert(r == NULL);
|
||||
/* Negative interval should get adjusted to zero */
|
||||
@ -55,8 +57,9 @@ test_replaycache_badalloc(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_replaycache_free_null(void)
|
||||
test_replaycache_free_null(void *arg)
|
||||
{
|
||||
(void)arg;
|
||||
replaycache_free(NULL);
|
||||
/* Assert that we're here without horrible death */
|
||||
tt_assert(1);
|
||||
@ -66,11 +69,12 @@ test_replaycache_free_null(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_replaycache_miss(void)
|
||||
test_replaycache_miss(void *arg)
|
||||
{
|
||||
replaycache_t *r = NULL;
|
||||
int result;
|
||||
|
||||
(void)arg;
|
||||
r = replaycache_new(600, 300);
|
||||
tt_assert(r != NULL);
|
||||
|
||||
@ -92,11 +96,12 @@ test_replaycache_miss(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_replaycache_hit(void)
|
||||
test_replaycache_hit(void *arg)
|
||||
{
|
||||
replaycache_t *r = NULL;
|
||||
int result;
|
||||
|
||||
(void)arg;
|
||||
r = replaycache_new(600, 300);
|
||||
tt_assert(r != NULL);
|
||||
|
||||
@ -117,11 +122,12 @@ test_replaycache_hit(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_replaycache_age(void)
|
||||
test_replaycache_age(void *arg)
|
||||
{
|
||||
replaycache_t *r = NULL;
|
||||
int result;
|
||||
|
||||
(void)arg;
|
||||
r = replaycache_new(600, 300);
|
||||
tt_assert(r != NULL);
|
||||
|
||||
@ -147,12 +153,13 @@ test_replaycache_age(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_replaycache_elapsed(void)
|
||||
test_replaycache_elapsed(void *arg)
|
||||
{
|
||||
replaycache_t *r = NULL;
|
||||
int result;
|
||||
time_t elapsed;
|
||||
|
||||
(void)arg;
|
||||
r = replaycache_new(600, 300);
|
||||
tt_assert(r != NULL);
|
||||
|
||||
@ -174,11 +181,12 @@ test_replaycache_elapsed(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_replaycache_noexpire(void)
|
||||
test_replaycache_noexpire(void *arg)
|
||||
{
|
||||
replaycache_t *r = NULL;
|
||||
int result;
|
||||
|
||||
(void)arg;
|
||||
r = replaycache_new(0, 0);
|
||||
tt_assert(r != NULL);
|
||||
|
||||
@ -204,11 +212,12 @@ test_replaycache_noexpire(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_replaycache_scrub(void)
|
||||
test_replaycache_scrub(void *arg)
|
||||
{
|
||||
replaycache_t *r = NULL;
|
||||
int result;
|
||||
|
||||
(void)arg;
|
||||
r = replaycache_new(600, 300);
|
||||
tt_assert(r != NULL);
|
||||
|
||||
@ -245,12 +254,13 @@ test_replaycache_scrub(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_replaycache_future(void)
|
||||
test_replaycache_future(void *arg)
|
||||
{
|
||||
replaycache_t *r = NULL;
|
||||
int result;
|
||||
time_t elapsed = 0;
|
||||
|
||||
(void)arg;
|
||||
r = replaycache_new(600, 300);
|
||||
tt_assert(r != NULL);
|
||||
|
||||
@ -288,7 +298,7 @@ test_replaycache_future(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_replaycache_realtime(void)
|
||||
test_replaycache_realtime(void *arg)
|
||||
{
|
||||
replaycache_t *r = NULL;
|
||||
/*
|
||||
@ -299,6 +309,7 @@ test_replaycache_realtime(void)
|
||||
int result;
|
||||
|
||||
/* Test the realtime as well as *_internal() entry points */
|
||||
(void)arg;
|
||||
r = replaycache_new(600, 300);
|
||||
tt_assert(r != NULL);
|
||||
|
||||
@ -329,7 +340,7 @@ test_replaycache_realtime(void)
|
||||
}
|
||||
|
||||
#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[] = {
|
||||
REPLAYCACHE_LEGACY(alloc),
|
||||
|
||||
@ -229,7 +229,7 @@ test_util_write_chunks_to_file(void *arg)
|
||||
}
|
||||
|
||||
static void
|
||||
test_util_time(void)
|
||||
test_util_time(void *arg)
|
||||
{
|
||||
struct timeval start, end;
|
||||
struct tm a_time;
|
||||
@ -240,6 +240,7 @@ test_util_time(void)
|
||||
|
||||
/* Test tv_udiff */
|
||||
|
||||
(void)arg;
|
||||
start.tv_sec = 5;
|
||||
start.tv_usec = 5000;
|
||||
|
||||
@ -459,13 +460,14 @@ test_util_parse_http_time(void *arg)
|
||||
}
|
||||
|
||||
static void
|
||||
test_util_config_line(void)
|
||||
test_util_config_line(void *arg)
|
||||
{
|
||||
char buf[1024];
|
||||
char *k=NULL, *v=NULL;
|
||||
const char *str;
|
||||
|
||||
/* Test parse_config_line_from_str */
|
||||
(void)arg;
|
||||
strlcpy(buf, "k v\n" " key value with spaces \n" "keykey val\n"
|
||||
"k2\n"
|
||||
"k3 \n" "\n" " \n" "#comment\n"
|
||||
@ -596,7 +598,7 @@ test_util_config_line(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_util_config_line_quotes(void)
|
||||
test_util_config_line_quotes(void *arg)
|
||||
{
|
||||
char buf1[1024];
|
||||
char buf2[128];
|
||||
@ -606,6 +608,7 @@ test_util_config_line_quotes(void)
|
||||
const char *str;
|
||||
|
||||
/* Test parse_config_line_from_str */
|
||||
(void)arg;
|
||||
strlcpy(buf1, "kTrailingSpace \"quoted value\" \n"
|
||||
"kTrailingGarbage \"quoted value\"trailing garbage\n"
|
||||
, sizeof(buf1));
|
||||
@ -650,13 +653,14 @@ test_util_config_line_quotes(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_util_config_line_comment_character(void)
|
||||
test_util_config_line_comment_character(void *arg)
|
||||
{
|
||||
char buf[1024];
|
||||
char *k=NULL, *v=NULL;
|
||||
const char *str;
|
||||
|
||||
/* Test parse_config_line_from_str */
|
||||
(void)arg;
|
||||
strlcpy(buf, "k1 \"# in quotes\"\n"
|
||||
"k2 some value # some comment\n"
|
||||
"k3 /home/user/myTorNetwork#2\n" /* Testcase for #1323 */
|
||||
@ -690,7 +694,7 @@ test_util_config_line_comment_character(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_util_config_line_escaped_content(void)
|
||||
test_util_config_line_escaped_content(void *arg)
|
||||
{
|
||||
char buf1[1024];
|
||||
char buf2[128];
|
||||
@ -702,6 +706,7 @@ test_util_config_line_escaped_content(void)
|
||||
const char *str;
|
||||
|
||||
/* Test parse_config_line_from_str */
|
||||
(void)arg;
|
||||
strlcpy(buf1, "HexadecimalLower \"\\x2a\"\n"
|
||||
"HexadecimalUpper \"\\x2A\"\n"
|
||||
"HexadecimalUpperX \"\\X2A\"\n"
|
||||
@ -827,10 +832,11 @@ test_util_config_line_escaped_content(void)
|
||||
|
||||
#ifndef _WIN32
|
||||
static void
|
||||
test_util_expand_filename(void)
|
||||
test_util_expand_filename(void *arg)
|
||||
{
|
||||
char *str;
|
||||
|
||||
(void)arg;
|
||||
setenv("HOME", "/home/itv", 1); /* For "internal test value" */
|
||||
|
||||
str = expand_filename("");
|
||||
@ -925,11 +931,12 @@ test_util_expand_filename(void)
|
||||
|
||||
/** Test tor_escape_str_for_pt_args(). */
|
||||
static void
|
||||
test_util_escape_string_socks(void)
|
||||
test_util_escape_string_socks(void *arg)
|
||||
{
|
||||
char *escaped_string = NULL;
|
||||
|
||||
/** Simple backslash escape. */
|
||||
(void)arg;
|
||||
escaped_string = tor_escape_str_for_pt_args("This is a backslash: \\",";\\");
|
||||
tt_assert(escaped_string);
|
||||
tt_str_op(escaped_string,==, "This is a backslash: \\\\");
|
||||
@ -983,13 +990,14 @@ test_util_string_is_key_value(void *ptr)
|
||||
|
||||
/** Test basic string functionality. */
|
||||
static void
|
||||
test_util_strmisc(void)
|
||||
test_util_strmisc(void *arg)
|
||||
{
|
||||
char buf[1024];
|
||||
int i;
|
||||
char *cp, *cp_tmp = NULL;
|
||||
|
||||
/* Test strl operations */
|
||||
(void)arg;
|
||||
tt_int_op(5,==, strlcpy(buf, "Hello", 0));
|
||||
tt_int_op(5,==, strlcpy(buf, "Hello", 10));
|
||||
tt_str_op(buf,==, "Hello");
|
||||
@ -1297,9 +1305,10 @@ test_util_strmisc(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_util_pow2(void)
|
||||
test_util_pow2(void *arg)
|
||||
{
|
||||
/* Test tor_log2(). */
|
||||
(void)arg;
|
||||
tt_int_op(tor_log2(64),==, 6);
|
||||
tt_int_op(tor_log2(65),==, 6);
|
||||
tt_int_op(tor_log2(63),==, 5);
|
||||
@ -1395,13 +1404,14 @@ thread_test_func_(void* _s)
|
||||
|
||||
/** Run unit tests for threading logic. */
|
||||
static void
|
||||
test_util_threads(void)
|
||||
test_util_threads(void *arg)
|
||||
{
|
||||
char *s1 = NULL, *s2 = NULL;
|
||||
int done = 0, timedout = 0;
|
||||
time_t started;
|
||||
#ifndef _WIN32
|
||||
struct timeval tv;
|
||||
(void)arg;
|
||||
tv.tv_sec=0;
|
||||
tv.tv_usec=100*1000;
|
||||
#endif
|
||||
@ -1470,13 +1480,14 @@ test_util_threads(void)
|
||||
|
||||
/** Run unit tests for compression functions */
|
||||
static void
|
||||
test_util_gzip(void)
|
||||
test_util_gzip(void *arg)
|
||||
{
|
||||
char *buf1=NULL, *buf2=NULL, *buf3=NULL, *cp1, *cp2;
|
||||
const char *ccp2;
|
||||
size_t len1, len2;
|
||||
tor_zlib_state_t *state = NULL;
|
||||
|
||||
(void)arg;
|
||||
buf1 = tor_strdup("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAAAAAAAAAAAAAAAAZ");
|
||||
tt_assert(detect_compression_method(buf1, strlen(buf1)) == UNKNOWN_METHOD);
|
||||
if (is_gzip_supported()) {
|
||||
@ -1579,7 +1590,7 @@ test_util_gzip(void)
|
||||
|
||||
/** Run unit tests for mmap() wrapper functionality. */
|
||||
static void
|
||||
test_util_mmap(void)
|
||||
test_util_mmap(void *arg)
|
||||
{
|
||||
char *fname1 = tor_strdup(get_fname("mapped_1"));
|
||||
char *fname2 = tor_strdup(get_fname("mapped_2"));
|
||||
@ -1588,6 +1599,7 @@ test_util_mmap(void)
|
||||
char *buf = tor_malloc(17000);
|
||||
tor_mmap_t *mapping = NULL;
|
||||
|
||||
(void)arg;
|
||||
crypto_rand(buf, buflen);
|
||||
|
||||
mapping = tor_mmap_file(fname1);
|
||||
@ -1655,13 +1667,14 @@ test_util_mmap(void)
|
||||
|
||||
/** Run unit tests for escaping/unescaping data for use by controllers. */
|
||||
static void
|
||||
test_util_control_formats(void)
|
||||
test_util_control_formats(void *arg)
|
||||
{
|
||||
char *out = NULL;
|
||||
const char *inp =
|
||||
"..This is a test\r\n.of the emergency \n..system.\r\n\rZ.\r\n";
|
||||
size_t sz;
|
||||
|
||||
(void)arg;
|
||||
sz = read_escaped_data(inp, strlen(inp), &out);
|
||||
tt_str_op(out,==,
|
||||
".This is a test\nof the emergency \n.system.\n\rZ.\n");
|
||||
@ -1685,7 +1698,7 @@ test_util_control_formats(void)
|
||||
} while (0)
|
||||
|
||||
static void
|
||||
test_util_sscanf(void)
|
||||
test_util_sscanf(void *arg)
|
||||
{
|
||||
unsigned u1, u2, u3;
|
||||
unsigned long ulng;
|
||||
@ -1696,6 +1709,7 @@ test_util_sscanf(void)
|
||||
double d1,d2,d3,d4;
|
||||
|
||||
/* 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("wrong", "%5c", s1)); /* %c cannot have 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
|
||||
test_util_path_is_relative(void)
|
||||
test_util_path_is_relative(void *arg)
|
||||
{
|
||||
/* OS-independent tests */
|
||||
(void)arg;
|
||||
tt_int_op(1,==, path_is_relative(""));
|
||||
tt_int_op(1,==, path_is_relative("dir"));
|
||||
tt_int_op(1,==, path_is_relative("dir/"));
|
||||
@ -2063,12 +2078,13 @@ test_util_path_is_relative(void)
|
||||
|
||||
/** Run unittests for memory pool allocator */
|
||||
static void
|
||||
test_util_mempool(void)
|
||||
test_util_mempool(void *arg)
|
||||
{
|
||||
mp_pool_t *pool = NULL;
|
||||
smartlist_t *allocated = NULL;
|
||||
int i;
|
||||
|
||||
(void)arg;
|
||||
pool = mp_pool_new(1, 100);
|
||||
tt_assert(pool);
|
||||
tt_assert(pool->new_chunk_capacity >= 100);
|
||||
@ -2123,13 +2139,14 @@ test_util_mempool(void)
|
||||
|
||||
/** Run unittests for memory area allocator */
|
||||
static void
|
||||
test_util_memarea(void)
|
||||
test_util_memarea(void *arg)
|
||||
{
|
||||
memarea_t *area = memarea_new();
|
||||
char *p1, *p2, *p3, *p1_orig;
|
||||
void *malloced_ptr = NULL;
|
||||
int i;
|
||||
|
||||
(void)arg;
|
||||
tt_assert(area);
|
||||
|
||||
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
|
||||
* the data directory. */
|
||||
static void
|
||||
test_util_datadir(void)
|
||||
test_util_datadir(void *arg)
|
||||
{
|
||||
char buf[1024];
|
||||
char *f = NULL;
|
||||
char *temp_dir = NULL;
|
||||
|
||||
(void)arg;
|
||||
temp_dir = get_datadir_fname(NULL);
|
||||
f = get_datadir_fname("state");
|
||||
tor_snprintf(buf, sizeof(buf), "%s"PATH_SEPARATOR"state", temp_dir);
|
||||
@ -2252,13 +2270,14 @@ test_util_datadir(void)
|
||||
}
|
||||
|
||||
static void
|
||||
test_util_strtok(void)
|
||||
test_util_strtok(void *arg)
|
||||
{
|
||||
char buf[128];
|
||||
char buf2[128];
|
||||
int i;
|
||||
char *cp1, *cp2;
|
||||
|
||||
(void)arg;
|
||||
for (i = 0; i < 3; i++) {
|
||||
const char *pad1="", *pad2="";
|
||||
switch (i) {
|
||||
@ -3314,7 +3333,7 @@ test_util_split_lines(void *ptr)
|
||||
}
|
||||
|
||||
static void
|
||||
test_util_di_ops(void)
|
||||
test_util_di_ops(void *arg)
|
||||
{
|
||||
#define LT -1
|
||||
#define GT 1
|
||||
@ -3334,6 +3353,7 @@ test_util_di_ops(void)
|
||||
|
||||
int i;
|
||||
|
||||
(void)arg;
|
||||
for (i = 0; examples[i].a; ++i) {
|
||||
size_t len = strlen(examples[i].a);
|
||||
int eq1, eq2, neq1, neq2, cmp1, cmp2;
|
||||
@ -3859,7 +3879,7 @@ test_util_strclear(void *arg)
|
||||
}
|
||||
|
||||
#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) \
|
||||
{ #name, test_util_ ## name, flags, NULL, NULL }
|
||||
|
||||
Loading…
Reference in New Issue
Block a user