static int
do_test (void)
{
for (const struct test_case *test = tests; test < array_end (tests); ++test)
{
if (test_verbose)
printf ("info: testing domain name [[[%s]]] (0x%x)\n",
test->dn, test->result);
one_test (test, "res_hnok", res_hnok, hnok);
one_test (test, "res_dnok", res_dnok, dnok);
one_test (test, "res_mailok", res_mailok, mailok);
one_test (test, "res_ownok", res_ownok, ownok);
}
one_char
("", LETTERSDIGITS "._", "", "res_hnok", res_hnok);
one_char
("middle",
LETTERSDIGITS ".-_\\", /* "middle\\suffix" == "middlesuffix", so good. */
"suffix", "res_hnok", res_hnok);
one_char
("middle",
LETTERSDIGITS ".-_" PRINTABLE,
"suffix.example", "res_mailok", res_mailok);
one_char
("mailbox.middle",
LETTERSDIGITS ".-_\\",
"suffix.example", "res_mailok", res_mailok);
return 0;
}
static void
all_tests (const char *name, int (*func) (int))
{
one_test (name, func, 0, true);
one_test (name, func, invalid_fd, true);
one_test (name, func, -1, false);
one_test (name, func, -2, false);
if (maxfd >= 0)
one_test (name, func, maxfd, false);
}
static int
do_test (void)
{
one_test ("no errno", -1,
L"tst-warn-wide: no errno\n");
one_test ("no errno", -2,
L"tst-warn-wide: no errno with padding " PADDING "\n");
one_test ("with errno", EAGAIN,
L"tst-warn-wide: with errno: Resource temporarily unavailable\n");
one_test ("with errno", E2BIG,
L"tst-warn-wide: with errno with padding " PADDING
": Argument list too long\n");
return 0;
}
static int
do_test (void)
{
/* Avoid network-based NSS modules and initialize nss_files with a
dummy lookup. This has to come before mtrace because NSS does
not free all memory. */
__nss_configure_lookup ("passwd", "files");
(void) getpwnam ("root");
mtrace ();
repeat = xmalloc (repeat_size + 1);
memset (repeat, 'x', repeat_size);
repeat[repeat_size] = '\0';
/* These numbers control the size of the user name. The values
cover the minimum (0), a typical size (8), a large
stack-allocated size (100000), and a somewhat large
heap-allocated size (largest_base_size). */
static const int base_sizes[] = { 0, 8, 100, 100000, largest_base_size, -1 };
for (do_onlydir = 0; do_onlydir < 2; ++do_onlydir)
for (do_nocheck = 0; do_nocheck < 2; ++do_nocheck)
for (do_mark = 0; do_mark < 2; ++do_mark)
for (do_noescape = 0; do_noescape < 2; ++do_noescape)
for (int base_idx = 0; base_sizes[base_idx] >= 0; ++base_idx)
{
for (int size_skew = -max_size_skew; size_skew <= max_size_skew;
++size_skew)
{
int size = base_sizes[base_idx] + size_skew;
if (size < 0)
continue;
const char *user_name = repeating_string (size);
one_test ("~", user_name, "/a/b");
one_test ("~", user_name, "x\\x\\x////x\\a");
}
const char *user_name = repeating_string (base_sizes[base_idx]);
one_test ("~", user_name, "");
one_test ("~", user_name, "/");
one_test ("~", user_name, "/a");
one_test ("~", user_name, "/*/*");
one_test ("~", user_name, "\\/");
one_test ("/~", user_name, "");
one_test ("*/~", user_name, "/a/b");
}
free (repeat);
return 0;
}
/* Test operands from a table of seed data. This variant creates the operands
using a division chain. This is a hack for better coverage of the gcd
code, which depends on that the random number generators give the exact
numbers we expect. */
void
check_kolmo2 (void)
{
static const struct {
unsigned int seed;
int nb, chain_len;
} data[] = {
{ 917, 15, 5 },
{ 1032, 18, 6 },
{ 1167, 18, 6 },
{ 1174, 18, 6 },
{ 1192, 18, 6 },
};
gmp_randstate_t rs;
mpz_t bs, a, b, want;
int i;
gmp_randinit_default (rs);
mpz_inits (bs, a, b, want, NULL);
for (i = 0; i < numberof (data); i++)
{
gmp_randseed_ui (rs, data[i].seed);
make_chain_operands (want, a, b, rs, data[i].nb, data[i].nb, data[i].chain_len);
one_test (a, b, want, -1);
}
mpz_clears (bs, a, b, want, NULL);
gmp_randclear (rs);
}
void *firethread_ot(void *param) {
struct thread_params_ot *threadparams = (struct thread_params_ot *)param;
/*child process*/
#if 0
#ifndef WIN32
fprintf(stderr, "Start of thread %u\n context=%u\n",
(unsigned int)pthread_self(),
(unsigned int)threadparams->context);
#endif
#endif
do {
one_test(threadparams->context, threadparams->name, threadparams->class_h,
threadparams->type_h, threadparams->flags,
threadparams->retvals, threadparams->doprint);
if (threadparams->wait)
sleep(threadparams->wait);
}while (threadparams->wait);
#if 0
#ifndef WIN32
fprintf(stderr, "End of thread %u\n",
(unsigned int)pthread_self());
#endif
#endif
return NULL;
}
static void
check_ed25519 (const char *fname)
{
FILE *fp;
int lineno, ntests;
char *line;
int testno;
char *sk, *pk, *msg, *sig;
show ("Checking Ed25519.\n");
fp = fopen (fname, "r");
if (!fp)
die ("error opening '%s': %s\n", fname, strerror (errno));
testno = 0;
sk = pk = msg = sig = NULL;
lineno = ntests = 0;
while ((line = read_textline (fp, &lineno)))
{
if (!strncmp (line, "TST:", 4))
testno = atoi (line+4);
else if (!strncmp (line, "SK:", 3))
copy_data (&sk, line, lineno);
else if (!strncmp (line, "PK:", 3))
copy_data (&pk, line, lineno);
else if (!strncmp (line, "MSG:", 4))
copy_data (&msg, line, lineno);
else if (!strncmp (line, "SIG:", 4))
copy_data (&sig, line, lineno);
else
fail ("unknown tag at input line %d", lineno);
xfree (line);
if (testno && sk && pk && msg && sig)
{
hexdowncase (sig);
one_test (testno, sk, pk, msg, sig);
ntests++;
if (!(ntests % 256))
show_note ("%d of %d tests done\n", ntests, N_TESTS);
xfree (pk); pk = NULL;
xfree (sk); sk = NULL;
xfree (msg); msg = NULL;
xfree (sig); sig = NULL;
}
}
xfree (pk);
xfree (sk);
xfree (msg);
xfree (sig);
if (ntests != N_TESTS && !custom_data_file)
fail ("did %d tests but expected %d", ntests, N_TESTS);
else if ((ntests % 256))
show_note ("%d tests done\n", ntests);
fclose (fp);
}
int
main(int argc, const char **argv)
{
long num_tests;
long num_elements;
long i;
if (argc != 3)
{
fprintf(stderr, "Usage: ipv4-set-size [# tests] [# elements]\n");
return -1;
}
num_tests = atol(argv[1]);
num_elements = atol(argv[2]);
fprintf(stderr, "Creating %lu sets with %lu elements each.\n",
num_tests, num_elements);
ipset_init_library();
srandom(time(NULL));
for (i = 0; i < num_tests; i++)
{
one_test(num_elements);
}
return 0;
}
int
main()
{
struct try
{
FLOAT x, y;
int result[6];
};
static struct try const data[] =
{
{ NAN, NAN, { 1, 0, 0, 0, 0, 0 } },
{ 0.0, NAN, { 1, 0, 0, 0, 0, 0 } },
{ NAN, 0.0, { 1, 0, 0, 0, 0, 0 } },
{ 0.0, 0.0, { 0, 0, 1, 0, 1, 0 } },
{ 1.0, 2.0, { 0, 1, 1, 0, 0, 1 } },
{ 2.0, 1.0, { 0, 0, 0, 1, 1, 1 } },
{ INF, 0.0, { 0, 0, 0, 1, 1, 1 } },
{ 1.0, INF, { 0, 1, 1, 0, 0, 1 } },
{ INF, INF, { 0, 0, 1, 0, 1, 0 } },
{ 0.0, -INF, { 0, 0, 0, 1, 1, 1 } },
{ -INF, 1.0, { 0, 1, 1, 0, 0, 1 } },
{ -INF, -INF, { 0, 0, 1, 0, 1, 0 } },
{ INF, -INF, { 0, 0, 0, 1, 1, 1 } },
{ -INF, INF, { 0, 1, 1, 0, 0, 1 } },
};
struct test
{
FLOAT (*pos)(FLOAT, FLOAT, FLOAT, FLOAT);
FLOAT (*neg)(FLOAT, FLOAT, FLOAT, FLOAT);
};
static struct test const tests[] =
{
{ test_isunordered, test_not_isunordered },
{ test_isless, test_not_isless },
{ test_islessequal, test_not_islessequal },
{ test_isgreater, test_not_isgreater },
{ test_isgreaterequal, test_not_isgreaterequal },
{ test_islessgreater, test_not_islessgreater }
};
const int n = sizeof(data) / sizeof(data[0]);
int i, j;
for (i = 0; i < n; ++i)
for (j = 0; j < 6; ++j)
one_test (data[i].x, data[i].y, data[i].result[j],
tests[j].pos, tests[j].neg);
exit (0);
}
static void test_max_message_length_type(void) {
grpc_arg client_arg;
grpc_channel_args client_args;
char *expected_error_message;
client_arg.type = GRPC_ARG_STRING;
client_arg.key = GRPC_ARG_MAX_MESSAGE_LENGTH;
client_arg.value.string = NULL;
client_args.num_args = 1;
client_args.args = &client_arg;
expected_error_message = compose_error_string(
GRPC_ARG_MAX_MESSAGE_LENGTH, " ignored: it must be an integer");
one_test(&client_args, expected_error_message);
}
static void test_ssl_name_override_type(void) {
grpc_arg client_arg;
grpc_channel_args client_args;
char *expected_error_message;
client_arg.type = GRPC_ARG_INTEGER;
client_arg.key = GRPC_SSL_TARGET_NAME_OVERRIDE_ARG;
client_arg.value.integer = 0;
client_args.num_args = 1;
client_args.args = &client_arg;
expected_error_message = compose_error_string(
GRPC_SSL_TARGET_NAME_OVERRIDE_ARG, " ignored: it must be a string");
one_test(&client_args, expected_error_message);
}
static void test_max_message_length_negative(void) {
grpc_arg client_arg;
grpc_channel_args client_args;
char *expected_error_message;
client_arg.type = GRPC_ARG_INTEGER;
client_arg.key = GRPC_ARG_MAX_MESSAGE_LENGTH;
client_arg.value.integer = -1;
client_args.num_args = 1;
client_args.args = &client_arg;
expected_error_message = compose_error_string(GRPC_ARG_MAX_MESSAGE_LENGTH,
" ignored: it must be >= 0");
one_test(&client_args, expected_error_message);
}
static void test_default_authority_type(void) {
grpc_arg client_arg;
grpc_channel_args client_args;
char *expected_error_message;
client_arg.type = GRPC_ARG_INTEGER;
client_arg.key = GRPC_ARG_DEFAULT_AUTHORITY;
client_arg.value.integer = 0;
client_args.num_args = 1;
client_args.args = &client_arg;
expected_error_message = compose_error_string(
GRPC_ARG_DEFAULT_AUTHORITY, " ignored: it must be a string");
one_test(&client_args, expected_error_message);
}
/* Test operands from a table of seed data. This variant creates the operands
using plain ol' mpz_rrandomb. This is a hack for better coverage of the gcd
code, which depends on that the random number generators give the exact
numbers we expect. */
void
check_kolmo1 (void)
{
static const struct {
unsigned int seed;
int nb;
const char *want;
} data[] = {
{ 59618, 38208, "5"},
{ 76521, 49024, "3"},
{ 85869, 54976, "1"},
{ 99449, 63680, "1"},
{112453, 72000, "1"}
};
gmp_randstate_t rs;
mpz_t bs, a, b, want;
int i, unb, vnb, nb;
gmp_randinit_default (rs);
mpz_inits (bs, a, b, want, NULL);
for (i = 0; i < numberof (data); i++)
{
nb = data[i].nb;
gmp_randseed_ui (rs, data[i].seed);
mpz_urandomb (bs, rs, 32);
unb = mpz_get_ui (bs) % nb;
mpz_urandomb (bs, rs, 32);
vnb = mpz_get_ui (bs) % nb;
mpz_rrandomb (a, rs, unb);
mpz_rrandomb (b, rs, vnb);
mpz_set_str_or_abort (want, data[i].want, 0);
one_test (a, b, want, -1);
}
mpz_clears (bs, a, b, want, NULL);
gmp_randclear (rs);
}
static void test_ssl_name_override_failed(void) {
grpc_arg client_arg[2];
grpc_channel_args client_args;
char *expected_error_message;
client_arg[0].type = GRPC_ARG_STRING;
client_arg[0].key = GRPC_ARG_DEFAULT_AUTHORITY;
client_arg[0].value.string = "default";
client_arg[1].type = GRPC_ARG_STRING;
client_arg[1].key = GRPC_SSL_TARGET_NAME_OVERRIDE_ARG;
client_arg[1].value.string = "ssl";
client_args.num_args = 2;
client_args.args = client_arg;
expected_error_message =
compose_error_string(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG,
" ignored: default host already set some other way");
one_test(&client_args, expected_error_message);
}
int
main (int argc, char **argv)
{
struct matrix A;
struct matrix B;
gmp_randstate_ptr rands;
mpz_t bs;
int i;
tests_start ();
rands = RANDS;
matrix_init (&A, MAX_SIZE);
matrix_init (&B, MAX_SIZE);
mpz_init (bs);
for (i = 0; i < 17; i++)
{
mp_size_t an, bn;
mpz_urandomb (bs, rands, 32);
an = 1 + mpz_get_ui (bs) % MAX_SIZE;
mpz_urandomb (bs, rands, 32);
bn = 1 + mpz_get_ui (bs) % MAX_SIZE;
matrix_random (&A, an, rands);
matrix_random (&B, bn, rands);
one_test (&A, &B, i);
}
mpz_clear (bs);
matrix_clear (&A);
matrix_clear (&B);
return 0;
}
int
main (int argc, char **argv)
{
mpz_t op1, op2, temp1, temp2;
int i, j, chain_len;
gmp_randstate_ptr rands;
mpz_t bs;
unsigned long size_range;
tests_start ();
rands = RANDS;
mpz_init (bs);
mpz_init (op1);
mpz_init (op2);
mpz_init (temp1);
mpz_init (temp2);
for (i = 0; hgcd_values[i].res >= 0; i++)
{
mp_size_t res;
mpz_set_str (op1, hgcd_values[i].a, 0);
mpz_set_str (op2, hgcd_values[i].b, 0);
res = one_test (op1, op2, -1-i);
if (res != hgcd_values[i].res)
{
fprintf (stderr, "ERROR in test %d\n", -1-i);
fprintf (stderr, "Bad return code from hgcd\n");
fprintf (stderr, "op1="); debug_mp (op1, -16);
fprintf (stderr, "op2="); debug_mp (op2, -16);
fprintf (stderr, "expected: %d\n", hgcd_values[i].res);
fprintf (stderr, "hgcd: %d\n", (int) res);
abort ();
}
}
for (i = 0; i < 15; i++)
{
/* Generate plain operands with unknown gcd. These types of operands
have proven to trigger certain bugs in development versions of the
gcd code. The "hgcd->row[3].rsize > M" ASSERT is not triggered by
the division chain code below, but that is most likely just a result
of that other ASSERTs are triggered before it. */
mpz_urandomb (bs, rands, 32);
size_range = mpz_get_ui (bs) % 13 + 2;
mpz_urandomb (bs, rands, size_range);
mpz_urandomb (op1, rands, mpz_get_ui (bs) + MIN_OPERAND_SIZE);
mpz_urandomb (bs, rands, size_range);
mpz_urandomb (op2, rands, mpz_get_ui (bs) + MIN_OPERAND_SIZE);
if (mpz_cmp (op1, op2) < 0)
mpz_swap (op1, op2);
if (mpz_size (op1) > 0)
one_test (op1, op2, i);
/* Generate a division chain backwards, allowing otherwise
unlikely huge quotients. */
mpz_set_ui (op1, 0);
mpz_urandomb (bs, rands, 32);
mpz_urandomb (bs, rands, mpz_get_ui (bs) % 16 + 1);
mpz_rrandomb (op2, rands, mpz_get_ui (bs));
mpz_add_ui (op2, op2, 1);
#if 0
chain_len = 1000000;
#else
mpz_urandomb (bs, rands, 32);
chain_len = mpz_get_ui (bs) % (GMP_NUMB_BITS * GCD_DC_THRESHOLD / 256);
#endif
for (j = 0; j < chain_len; j++)
{
mpz_urandomb (bs, rands, 32);
mpz_urandomb (bs, rands, mpz_get_ui (bs) % 12 + 1);
mpz_rrandomb (temp2, rands, mpz_get_ui (bs) + 1);
mpz_add_ui (temp2, temp2, 1);
mpz_mul (temp1, op2, temp2);
mpz_add (op1, op1, temp1);
/* Don't generate overly huge operands. */
if (SIZ (op1) > 3 * GCD_DC_THRESHOLD)
break;
mpz_urandomb (bs, rands, 32);
mpz_urandomb (bs, rands, mpz_get_ui (bs) % 12 + 1);
mpz_rrandomb (temp2, rands, mpz_get_ui (bs) + 1);
mpz_add_ui (temp2, temp2, 1);
mpz_mul (temp1, op1, temp2);
mpz_add (op2, op2, temp1);
/* Don't generate overly huge operands. */
if (SIZ (op2) > 3 * GCD_DC_THRESHOLD)
break;
}
if (mpz_cmp (op1, op2) < 0)
mpz_swap (op1, op2);
if (mpz_size (op1) > 0)
one_test (op1, op2, i);
}
mpz_clear (bs);
mpz_clear (op1);
mpz_clear (op2);
mpz_clear (temp1);
mpz_clear (temp2);
tests_end ();
exit (0);
}
static void test_no_error_message(void) { one_test(NULL, NULL); }
int
main (int argc, char **argv)
{
mpz_t op1, op2, ref;
int i, j, chain_len;
gmp_randstate_ptr rands;
mpz_t bs;
unsigned long bsi, size_range;
int reps = 200;
if (argc == 2)
reps = atoi (argv[1]);
tests_start ();
rands = RANDS;
check_data ();
mpz_init (bs);
mpz_init (op1);
mpz_init (op2);
mpz_init (ref);
mpz_init (gcd1);
mpz_init (gcd2);
mpz_init (temp1);
mpz_init (temp2);
mpz_init (s);
mpz_init (t);
for (i = 0; i < reps; i++)
{
/* Generate plain operands with unknown gcd. These types of operands
have proven to trigger certain bugs in development versions of the
gcd code. The "hgcd->row[3].rsize > M" ASSERT is not triggered by
the division chain code below, but that is most likely just a result
of that other ASSERTs are triggered before it. */
mpz_urandomb (bs, rands, 32);
size_range = mpz_get_ui (bs) % 13 + 2;
mpz_urandomb (bs, rands, size_range);
mpz_urandomb (op1, rands, mpz_get_ui (bs) + MIN_OPERAND_BITSIZE);
mpz_urandomb (bs, rands, size_range);
mpz_urandomb (op2, rands, mpz_get_ui (bs) + MIN_OPERAND_BITSIZE);
mpz_urandomb (bs, rands, 2);
bsi = mpz_get_ui (bs);
if ((bsi & 1) != 0)
mpz_neg (op1, op1);
if ((bsi & 2) != 0)
mpz_neg (op2, op2);
one_test (op1, op2, NULL, i);
/* Generate a division chain backwards, allowing otherwise unlikely huge
quotients. */
mpz_set_ui (op1, 0);
mpz_urandomb (bs, rands, 32);
mpz_urandomb (bs, rands, mpz_get_ui (bs) % 16 + 1);
mpz_rrandomb (op2, rands, mpz_get_ui (bs));
mpz_add_ui (op2, op2, 1);
mpz_set (ref, op2);
mpz_urandomb (bs, rands, 32);
chain_len = mpz_get_ui (bs) % 50;
for (j = 0; j < chain_len; j++)
{
mpz_urandomb (bs, rands, 32);
mpz_urandomb (bs, rands, mpz_get_ui (bs) % 12 + 1);
mpz_rrandomb (temp2, rands, mpz_get_ui (bs) + 1);
mpz_add_ui (temp2, temp2, 1);
mpz_mul (temp1, op2, temp2);
mpz_add (op1, op1, temp1);
/* Don't generate overly huge operands. */
if (SIZ (op1) > 400)
break;
mpz_urandomb (bs, rands, 32);
mpz_urandomb (bs, rands, mpz_get_ui (bs) % 12 + 1);
mpz_rrandomb (temp2, rands, mpz_get_ui (bs) + 1);
mpz_add_ui (temp2, temp2, 1);
mpz_mul (temp1, op1, temp2);
mpz_add (op2, op2, temp1);
/* Don't generate overly huge operands. */
if (SIZ (op2) > 400)
break;
}
one_test (op1, op2, ref, i);
}
mpz_clear (bs);
mpz_clear (op1);
mpz_clear (op2);
mpz_clear (ref);
mpz_clear (gcd1);
mpz_clear (gcd2);
mpz_clear (temp1);
mpz_clear (temp2);
mpz_clear (s);
mpz_clear (t);
tests_end ();
exit (0);
}
int
main (int argc, char **argv)
{
mpz_t op1, op2, ref;
int i, chain_len;
gmp_randstate_ptr rands;
mpz_t bs;
unsigned long bsi, size_range;
long int reps = 200;
tests_start ();
TESTS_REPS (reps, argv, argc);
rands = RANDS;
mpz_inits (bs, op1, op2, ref, gcd1, gcd2, temp1, temp2, temp3, s, NULL);
check_data ();
check_kolmo1 ();
check_kolmo2 ();
/* Testcase to exercise the u0 == u1 case in mpn_gcdext_lehmer_n. */
mpz_set_ui (op2, GMP_NUMB_MAX); /* FIXME: Huge limb doesn't always fit */
mpz_mul_2exp (op1, op2, 100);
mpz_add (op1, op1, op2);
mpz_mul_ui (op2, op2, 2);
one_test (op1, op2, NULL, -1);
for (i = 0; i < reps; i++)
{
/* Generate plain operands with unknown gcd. These types of operands
have proven to trigger certain bugs in development versions of the
gcd code. The "hgcd->row[3].rsize > M" ASSERT is not triggered by
the division chain code below, but that is most likely just a result
of that other ASSERTs are triggered before it. */
mpz_urandomb (bs, rands, 32);
size_range = mpz_get_ui (bs) % 17 + 2;
mpz_urandomb (bs, rands, size_range);
mpz_rrandomb (op1, rands, mpz_get_ui (bs) + MIN_OPERAND_BITSIZE);
mpz_urandomb (bs, rands, size_range);
mpz_rrandomb (op2, rands, mpz_get_ui (bs) + MIN_OPERAND_BITSIZE);
mpz_urandomb (bs, rands, 8);
bsi = mpz_get_ui (bs);
if ((bsi & 0x3c) == 4)
mpz_mul (op1, op1, op2); /* make op1 a multiple of op2 */
else if ((bsi & 0x3c) == 8)
mpz_mul (op2, op1, op2); /* make op2 a multiple of op1 */
if ((bsi & 1) != 0)
mpz_neg (op1, op1);
if ((bsi & 2) != 0)
mpz_neg (op2, op2);
one_test (op1, op2, NULL, i);
/* Generate a division chain backwards, allowing otherwise unlikely huge
quotients. */
mpz_urandomb (bs, rands, 32);
chain_len = mpz_get_ui (bs) % LOG2C (GMP_NUMB_BITS * MAX_SCHOENHAGE_THRESHOLD);
mpz_urandomb (bs, rands, 32);
chain_len = mpz_get_ui (bs) % (1 << chain_len) / 32;
make_chain_operands (ref, op1, op2, rands, 16, 12, chain_len);
one_test (op1, op2, ref, i);
}
mpz_clears (bs, op1, op2, ref, gcd1, gcd2, temp1, temp2, temp3, s, NULL);
tests_end ();
exit (0);
}
/*============================================================================
*
* main() BEGINS HERE
*
*===========================================================================*/
int
main(int argc, char *argv[])
{
val_context_t *context = NULL;
// Parse the command line for a query and resolve+validate it
int c;
char *domain_name = NULL;
const char *args = "c:dF:hi:I:l:m:nw:o:pr:S:st:T:v:V";
int class_h = ns_c_in;
int type_h = ns_t_a;
int success = 0;
int doprint = 0;
int selftest = 0;
int num_threads = 0;
int max_in_flight = 1;
int daemon = 0;
//u_int32_t flags = VAL_QUERY_AC_DETAIL|VAL_QUERY_NO_EDNS0_FALLBACK|VAL_QUERY_SKIP_CACHE;
u_int32_t flags = VAL_QUERY_AC_DETAIL;
u_int32_t nodnssec_flag = 0;
int retvals[] = { 0 };
int tcs = 0, tce = -1;
int wait = 0;
char *label_str = NULL, *nextarg = NULL;
char *suite = NULL, *testcase_config = NULL;
val_log_t *logp;
int rc;
if (argc == 1)
return 0;
while (1) {
#ifdef HAVE_GETOPT_LONG
int opt_index = 0;
#ifdef HAVE_GETOPT_LONG_ONLY
c = getopt_long_only(argc, argv, args, prog_options, &opt_index);
#else
c = getopt_long(argc, argv, args, prog_options, &opt_index);
#endif
#else /* only have getopt */
c = getopt(argc, argv, args);
#endif
if (c == -1) {
break;
}
switch (c) {
case 'h':
usage(argv[0]);
return (-1);
case 'F':
testcase_config = optarg;
break;
case 'd':
daemon = 1;
break;
case 's':
selftest = 1;
if (NULL != suite) {
fprintf(stderr,
"Warning: -s runs all tests.\n"
" ignoring previous suite(s).\n");
suite = NULL; /* == all suites */
}
break;
case 'S':
if (selftest) {
if (NULL == suite)
fprintf(stderr,
"Warning: -s runs all tests.\n"
" ignoring specified suite.\n");
else {
fprintf(stderr,
"Warning: -S may only be specified once.\n"
" ignoring previous suite.\n");
suite = optarg;
}
}
else {
selftest = 1;
suite = optarg;
}
break;
case 'p':
doprint = 1;
break;
case 'n':
nodnssec_flag = 1;
break;
case 'c':
// optarg is a global variable. See man page for getopt_long(3).
class_h = res_nametoclass(optarg, &success);
if (!success) {
fprintf(stderr, "Cannot parse class %s\n", optarg);
usage(argv[0]);
return -1;
}
break;
case 'o':
logp = val_log_add_optarg(optarg, 1);
if (NULL == logp) { /* err msg already logged */
usage(argv[0]);
return -1;
}
break;
case 'I':
#ifndef VAL_NO_ASYNC
max_in_flight = strtol(optarg, &nextarg, 10);
#else
fprintf(stderr, "libval was built without asynchronous support\n");
fprintf(stderr, "ignoring -I parameter\n");
#endif /* ndef VAL_NO_ASYNC */
break;
case 'm':
num_threads = atoi(optarg);
break;
case 'v':
dnsval_conf_set(optarg);
break;
case 'i':
root_hints_set(optarg);
break;
case 'r':
resolv_conf_set(optarg);
break;
case 'w':
wait = strtol(optarg, &nextarg, 10);
break;
case 't':
type_h = res_nametotype(optarg, &success);
if (!success) {
fprintf(stderr, "Cannot parse type %s\n", optarg);
usage(argv[0]);
return -1;
}
break;
case 'T':
tcs = strtol(optarg, &nextarg, 10);
if (*nextarg == '\0')
tce = tcs;
else
tce = atoi(++nextarg);
break;
case 'l':
label_str = optarg;
break;
case 'V':
version();
return 0;
default:
fprintf(stderr, "Unknown option %s (c = %d [%c])\n",
argv[optind - 1], c, (char) c);
usage(argv[0]);
return -1;
} // end switch
}
if (daemon) {
endless_loop();
return 0;
}
#ifndef TEST_NULL_CTX_CREATION
if (VAL_NO_ERROR !=
(rc = val_create_context(label_str, &context))) {
fprintf(stderr, "Cannot create context: %d\n", rc);
return -1;
}
#else
context = NULL;
#endif
/* returned level is 0 based;, > 6 means 7 or higher; e.g. -o 7:stdout */
if (val_log_highest_debug_level() > 6)
res_set_debug_level(val_log_highest_debug_level());
rc = 0;
if (nodnssec_flag) {
val_context_setqflags(context, VAL_CTX_FLAG_SET,
VAL_QUERY_DONT_VALIDATE);
}
// optind is a global variable. See man page for getopt_long(3)
if (optind >= argc) {
if (!selftest && (tcs == -1)) {
fprintf(stderr, "Please specify domain name\n");
usage(argv[0]);
rc = -1;
goto done;
} else {
#ifndef VAL_NO_THREADS
if (num_threads > 0) {
struct thread_params_st
threadparams = {context, tcs, tce, flags, testcase_config,
suite, doprint, wait, max_in_flight};
do_threads(num_threads, &threadparams);
fprintf(stderr, "Parent exiting\n");
} else {
#endif /* VAL_NO_THREADS */
do { /* endless loop */
rc = self_test(context, tcs, tce, flags, testcase_config,
suite, doprint, max_in_flight);
if (wait)
sleep(wait);
} while (wait && !rc);
#ifndef VAL_NO_THREADS
}
#endif /* VAL_NO_THREADS */
}
goto done;
}
domain_name = argv[optind++];
#ifndef VAL_NO_THREADS
if (num_threads > 0) {
struct thread_params_st
threadparams = {context, tcs, tce, flags, testcase_config,
suite, doprint, wait, max_in_flight};
do_threads(num_threads, &threadparams);
} else {
#endif /* VAL_NO_THREADS */
do { /* endless loop */
rc = one_test(context, domain_name, class_h, type_h, flags, retvals,
doprint);
if (wait)
sleep(wait);
} while (wait);
#ifndef VAL_NO_THREADS
}
#endif /* VAL_NO_THREADS */
done:
if (context)
val_free_context(context);
val_free_validator_state();
return rc;
}
int
main (int argc, char **argv)
{
mpz_t op1, op2, temp1, temp2;
int i, j, chain_len;
gmp_randstate_ptr rands;
mpz_t bs;
unsigned long size_range;
if (argc > 1)
{
if (strcmp (argv[1], "-v") == 0)
verbose_flag = 1;
else
{
fprintf (stderr, "Invalid argument.\n");
return 1;
}
}
tests_start ();
rands = RANDS;
mpz_init (bs);
mpz_init (op1);
mpz_init (op2);
mpz_init (temp1);
mpz_init (temp2);
for (i = 0; i < 15; i++)
{
/* Generate plain operands with unknown gcd. These types of operands
have proven to trigger certain bugs in development versions of the
gcd code. */
mpz_urandomb (bs, rands, 32);
size_range = mpz_get_ui (bs) % 13 + 2;
mpz_urandomb (bs, rands, size_range);
mpz_urandomb (op1, rands, mpz_get_ui (bs) + MIN_OPERAND_SIZE);
mpz_urandomb (bs, rands, size_range);
mpz_urandomb (op2, rands, mpz_get_ui (bs) + MIN_OPERAND_SIZE);
if (mpz_cmp (op1, op2) < 0)
mpz_swap (op1, op2);
if (mpz_size (op1) > 0)
one_test (op1, op2, i);
/* Generate a division chain backwards, allowing otherwise
unlikely huge quotients. */
mpz_set_ui (op1, 0);
mpz_urandomb (bs, rands, 32);
mpz_urandomb (bs, rands, mpz_get_ui (bs) % 16 + 1);
mpz_rrandomb (op2, rands, mpz_get_ui (bs));
mpz_add_ui (op2, op2, 1);
#if 0
chain_len = 1000000;
#else
mpz_urandomb (bs, rands, 32);
chain_len = mpz_get_ui (bs) % (GMP_NUMB_BITS * GCD_DC_THRESHOLD / 256);
#endif
for (j = 0; j < chain_len; j++)
{
mpz_urandomb (bs, rands, 32);
mpz_urandomb (bs, rands, mpz_get_ui (bs) % 12 + 1);
mpz_rrandomb (temp2, rands, mpz_get_ui (bs) + 1);
mpz_add_ui (temp2, temp2, 1);
mpz_mul (temp1, op2, temp2);
mpz_add (op1, op1, temp1);
/* Don't generate overly huge operands. */
if (SIZ (op1) > 3 * GCD_DC_THRESHOLD)
break;
mpz_urandomb (bs, rands, 32);
mpz_urandomb (bs, rands, mpz_get_ui (bs) % 12 + 1);
mpz_rrandomb (temp2, rands, mpz_get_ui (bs) + 1);
mpz_add_ui (temp2, temp2, 1);
mpz_mul (temp1, op1, temp2);
mpz_add (op2, op2, temp1);
/* Don't generate overly huge operands. */
if (SIZ (op2) > 3 * GCD_DC_THRESHOLD)
break;
}
if (mpz_cmp (op1, op2) < 0)
mpz_swap (op1, op2);
if (mpz_size (op1) > 0)
one_test (op1, op2, i);
}
mpz_clear (bs);
mpz_clear (op1);
mpz_clear (op2);
mpz_clear (temp1);
mpz_clear (temp2);
tests_end ();
exit (0);
}
int
main (int argc, char **argv)
{
mpz_t op1, op2, ref;
int i, j, chain_len;
gmp_randstate_ptr rands;
mpz_t bs;
unsigned long bsi, size_range;
int reps = 200;
tests_start ();
TESTS_REPS (reps, argv, argc);
rands = RANDS;
check_data ();
mpz_init (bs);
mpz_init (op1);
mpz_init (op2);
mpz_init (ref);
mpz_init (gcd1);
mpz_init (gcd2);
mpz_init (temp1);
mpz_init (temp2);
mpz_init (temp3);
mpz_init (s);
mpz_init (t);
/* Testcase to exercise the u0 == u1 case in mpn_gcdext_lehmer_n. */
mpz_set_ui (op2, GMP_NUMB_MAX);
mpz_mul_2exp (op1, op2, 100);
mpz_add (op1, op1, op2);
mpz_mul_ui (op2, op2, 2);
one_test (op1, op2, NULL, -1);
#if 0
mpz_set_str (op1, "4da8e405e0d2f70d6d679d3de08a5100a81ec2cff40f97b313ae75e1183f1df2b244e194ebb02a4ece50d943640a301f0f6cc7f539117b783c3f3a3f91649f8a00d2e1444d52722810562bce02fccdbbc8fe3276646e306e723dd3b", 16);
mpz_set_str (op2, "76429e12e4fdd8929d89c21657097fbac09d1dc08cf7f1323a34e78ca34226e1a7a29b86fee0fa7fe2cc2a183d46d50df1fe7029590974ad7da77605f35f902cb8b9b8d22dd881eaae5919675d49a337145a029c3b33fc2b0", 16);
one_test (op1, op2, NULL, -1);
#endif
for (i = 0; i < reps; i++)
{
/* Generate plain operands with unknown gcd. These types of operands
have proven to trigger certain bugs in development versions of the
gcd code. The "hgcd->row[3].rsize > M" ASSERT is not triggered by
the division chain code below, but that is most likely just a result
of that other ASSERTs are triggered before it. */
mpz_urandomb (bs, rands, 32);
size_range = mpz_get_ui (bs) % 17 + 2;
mpz_urandomb (bs, rands, size_range);
mpz_rrandomb (op1, rands, mpz_get_ui (bs) + MIN_OPERAND_BITSIZE);
mpz_urandomb (bs, rands, size_range);
mpz_rrandomb (op2, rands, mpz_get_ui (bs) + MIN_OPERAND_BITSIZE);
mpz_urandomb (bs, rands, 8);
bsi = mpz_get_ui (bs);
if ((bsi & 0x3c) == 4)
mpz_mul (op1, op1, op2); /* make op1 a multiple of op2 */
else if ((bsi & 0x3c) == 8)
mpz_mul (op2, op1, op2); /* make op2 a multiple of op1 */
if ((bsi & 1) != 0)
mpz_neg (op1, op1);
if ((bsi & 2) != 0)
mpz_neg (op2, op2);
one_test (op1, op2, NULL, i);
/* Generate a division chain backwards, allowing otherwise unlikely huge
quotients. */
mpz_set_ui (op1, 0);
mpz_urandomb (bs, rands, 32);
mpz_urandomb (bs, rands, mpz_get_ui (bs) % 16 + 1);
mpz_rrandomb (op2, rands, mpz_get_ui (bs));
mpz_add_ui (op2, op2, 1);
mpz_set (ref, op2);
#if WHACK_SCHOENHAGE
chain_len = 1000000;
#else
mpz_urandomb (bs, rands, 32);
chain_len = mpz_get_ui (bs) % (GMP_NUMB_BITS * MAX_SCHOENHAGE_THRESHOLD / 256);
#endif
for (j = 0; j < chain_len; j++)
{
mpz_urandomb (bs, rands, 32);
mpz_urandomb (bs, rands, mpz_get_ui (bs) % 12 + 1);
mpz_rrandomb (temp2, rands, mpz_get_ui (bs) + 1);
mpz_add_ui (temp2, temp2, 1);
mpz_mul (temp1, op2, temp2);
mpz_add (op1, op1, temp1);
/* Don't generate overly huge operands. */
if (SIZ (op1) > 3 * MAX_SCHOENHAGE_THRESHOLD)
break;
mpz_urandomb (bs, rands, 32);
mpz_urandomb (bs, rands, mpz_get_ui (bs) % 12 + 1);
mpz_rrandomb (temp2, rands, mpz_get_ui (bs) + 1);
mpz_add_ui (temp2, temp2, 1);
mpz_mul (temp1, op1, temp2);
mpz_add (op2, op2, temp1);
/* Don't generate overly huge operands. */
if (SIZ (op2) > 3 * MAX_SCHOENHAGE_THRESHOLD)
break;
}
one_test (op1, op2, ref, i);
}
mpz_clear (bs);
mpz_clear (op1);
mpz_clear (op2);
mpz_clear (ref);
mpz_clear (gcd1);
mpz_clear (gcd2);
mpz_clear (temp1);
mpz_clear (temp2);
mpz_clear (temp3);
mpz_clear (s);
mpz_clear (t);
tests_end ();
exit (0);
}
