void
check_data (void)
{
static const struct {
int base;
const char *num;
const char *den;
const char *want;
} data[] = {
{ 10, "0", "1", "0" },
{ 10, "1", "1", "1" },
{ 16, "ffffffff", "1", "ffffffff" },
{ 16, "ffffffffffffffff", "1", "ffffffffffffffff" },
{ 16, "1", "ffffffff", "1/ffffffff" },
{ 16, "1", "ffffffffffffffff", "1/ffffffffffffffff" },
{ 16, "1", "10000000000000003", "1/10000000000000003" },
{ 10, "12345678901234567890", "9876543210987654323",
"12345678901234567890/9876543210987654323" },
};
mpq_t q;
int i;
mpq_init (q);
for (i = 0; i < numberof (data); i++)
{
mpz_set_str_or_abort (mpq_numref(q), data[i].num, data[i].base);
mpz_set_str_or_abort (mpq_denref(q), data[i].den, data[i].base);
check_all (q, data[i].base, data[i].want);
}
mpq_clear (q);
}
void
check_data (void)
{
static const struct {
const char *a;
const char *c;
const char *d;
int want;
} data[] = {
/* strict equality mod 0 */
{ "0", "0", "0", 1 },
{ "11", "11", "0", 1 },
{ "3", "11", "0", 0 },
/* anything congruent mod 1 */
{ "0", "0", "1", 1 },
{ "1", "0", "1", 1 },
{ "0", "1", "1", 1 },
{ "123", "456", "1", 1 },
{ "0x123456789123456789", "0x987654321987654321", "1", 1 },
/* csize==1, dsize==2 changing to 1 after stripping 2s */
{ "0x3333333333333333", "0x33333333",
"0x180000000", 1 },
{ "0x33333333333333333333333333333333", "0x3333333333333333",
"0x18000000000000000", 1 },
/* another dsize==2 becoming 1, with opposite signs this time */
{ "0x444444441",
"-0x22222221F",
"0x333333330", 1 },
{ "0x44444444444444441",
"-0x2222222222222221F",
"0x33333333333333330", 1 },
};
mpz_t a, c, d;
int i;
mpz_init (a);
mpz_init (c);
mpz_init (d);
for (i = 0; i < numberof (data); i++)
{
mpz_set_str_or_abort (a, data[i].a, 0);
mpz_set_str_or_abort (c, data[i].c, 0);
mpz_set_str_or_abort (d, data[i].d, 0);
check_one (a, c, d, data[i].want);
}
mpz_clear (a);
mpz_clear (c);
mpz_clear (d);
}
void
check_data (void)
{
static const struct {
const char *a;
const char *d;
int want;
} data[] = {
{ "0", "0", 1 },
{ "17", "0", 0 },
{ "0", "1", 1 },
{ "123", "1", 1 },
{ "-123", "1", 1 },
{ "0", "2", 1 },
{ "1", "2", 0 },
{ "2", "2", 1 },
{ "-2", "2", 1 },
{ "0x100000000000000000000000000000000", "2", 1 },
{ "0x100000000000000000000000000000001", "2", 0 },
{ "0x3333333333333333", "3", 1 },
{ "0x3333333333333332", "3", 0 },
{ "0x33333333333333333333333333333333", "3", 1 },
{ "0x33333333333333333333333333333332", "3", 0 },
/* divisor changes from 2 to 1 limb after stripping 2s */
{ "0x3333333300000000", "0x180000000", 1 },
{ "0x33333333333333330000000000000000", "0x18000000000000000", 1 },
{ "0x133333333333333330000000000000000", "0x18000000000000000", 0 },
};
mpz_t a, d;
int i;
mpz_init (a);
mpz_init (d);
for (i = 0; i < numberof (data); i++)
{
mpz_set_str_or_abort (a, data[i].a, 0);
mpz_set_str_or_abort (d, data[i].d, 0);
check_one (a, d, data[i].want);
}
mpz_clear (a);
mpz_clear (d);
}
static void
check_primes (void)
{
static const char * const primes[] = {
"2", "17", "65537",
/* diffie-hellman-group1-sha1, also "Well known group 2" in RFC
2412, 2^1024 - 2^960 - 1 + 2^64 * { [2^894 pi] + 129093 } */
"0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
"29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
"EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
"E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
"EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381"
"FFFFFFFFFFFFFFFF",
NULL
};
mpz_t n;
int i;
mpz_init (n);
for (i = 0; primes[i]; i++)
{
mpz_set_str_or_abort (n, primes[i], 0);
check_one (n, 1);
}
mpz_clear (n);
}
void
check_data (void)
{
static const struct {
const char *a;
const char *b;
const char *want;
} data[] = {
/* This tickled a bug in gmp 4.1.2 mpn/x86/k6/gcd_finda.asm. */
{ "0x3FFC000007FFFFFFFFFF00000000003F83FFFFFFFFFFFFFFF80000000000000001",
"0x1FFE0007FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC000000000000000000000001",
"5" }
};
mpz_t a, b, got, want;
int i;
mpz_init (a);
mpz_init (b);
mpz_init (got);
mpz_init (want);
for (i = 0; i < numberof (data); i++)
{
mpz_set_str_or_abort (a, data[i].a, 0);
mpz_set_str_or_abort (b, data[i].b, 0);
mpz_set_str_or_abort (want, data[i].want, 0);
mpz_gcd (got, a, b);
MPZ_CHECK_FORMAT (got);
if (mpz_cmp (got, want) != 0)
{
printf ("mpz_gcd wrong on data[%d]\n", i);
printf (" a %s\n", data[i].a);
printf (" b %s\n", data[i].b);
mpz_trace (" a", a);
mpz_trace (" b", b);
mpz_trace (" want", want);
mpz_trace (" got ", got);
abort ();
}
}
mpz_clear (a);
mpz_clear (b);
mpz_clear (got);
mpz_clear (want);
}
void
check_data (void)
{
static const struct {
const char *x;
double y;
int cmp, cmpabs;
} data[] = {
{ "0", 0.0, 0, 0 },
{ "1", 0.0, 1, 1 },
{ "-1", 0.0, -1, 1 },
{ "1", 0.5, 1, 1 },
{ "-1", -0.5, -1, 1 },
{ "0", 1.0, -1, -1 },
{ "0", -1.0, 1, -1 },
{ "0x1000000000000000000000000000000000000000000000000", 1.0, 1, 1 },
{ "-0x1000000000000000000000000000000000000000000000000", 1.0, -1, 1 },
{ "0", 1e100, -1, -1 },
{ "0", -1e100, 1, -1 },
{ "2", 1.5, 1, 1 },
{ "2", -1.5, 1, 1 },
{ "-2", 1.5, -1, 1 },
{ "-2", -1.5, -1, 1 },
};
mpz_t x;
unsigned i;
mpz_init (x);
for (i = 0; i < numberof (data); i++)
{
mpz_set_str_or_abort (x, data[i].x, 0);
check_one ("check_data", x, data[i].y, data[i].cmp, data[i].cmpabs);
}
mpz_clear (x);
}
/* 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);
}
void
check_data (void)
{
static const struct {
const char *n;
unsigned long want;
} data[] = {
{ "-1", ~ (unsigned long) 0 },
{ "-12345678", ~ (unsigned long) 0 },
{ "0", 0 },
{ "1", 1 },
{ "3", 2 },
{ "5", 2 },
{ "0xFFFF", 16 },
{ "0xFFFFFFFF", 32 },
{ "0xFFFFFFFFFFFFFFFF", 64 },
{ "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 128 },
};
unsigned long got;
int i;
mpz_t n;
mpz_init (n);
for (i = 0; i < numberof (data); i++)
{
mpz_set_str_or_abort (n, data[i].n, 0);
got = mpz_popcount (n);
if (got != data[i].want)
{
printf ("mpz_popcount wrong at data[%d]\n", i);
printf (" n \"%s\"\n", data[i].n);
printf (" "); mpz_out_str (stdout, 10, n); printf ("\n");
printf (" 0x"); mpz_out_str (stdout, 16, n); printf ("\n");
printf (" got %lu\n", got);
printf (" want %lu\n", data[i].want);
abort ();
}
}
mpz_clear (n);
}
void
check_data (void)
{
static const struct {
const char *n;
long want;
} data[] = {
{ "0", 0L },
{ "1", 1L },
{ "-1", -1L },
{ "2", 2L },
{ "-2", -2L },
{ "12345", 12345L },
{ "-12345", -12345L },
};
int i;
mpz_t n;
long got;
mpz_init (n);
for (i = 0; i < numberof (data); i++)
{
mpz_set_str_or_abort (n, data[i].n, 0);
got = mpz_get_si (n);
if (got != data[i].want)
{
printf ("mpz_get_si wrong at data[%d]\n", i);
printf (" n \"%s\" (", data[i].n);
mpz_out_str (stdout, 10, n); printf (", hex ");
mpz_out_str (stdout, 16, n); printf (")\n");
printf (" got %ld (0x%lX)\n", got, got);
printf (" want %ld (0x%lX)\n", data[i].want, data[i].want);
abort();
}
}
mpz_clear (n);
}
void
check_data (void)
{
static const struct {
int a_base;
const char *a;
const char *b;
int want;
} data[] = {
{ 10, "0", "1", -1 },
{ 10, "0", "0", 0 },
{ 10, "0", "-1", 1 },
{ 10, "1", "1", 0 },
{ 10, "1", "0", 1 },
{ 10, "1", "-1", 1 },
{ 10, "-1", "1", -1 },
{ 10, "-1", "0", -1 },
{ 10, "-1", "-1", 0 },
{ 16, "0", "-0x80000000", 1 },
{ 16, "80000000", "-0x80000000", 1 },
{ 16, "80000001", "-0x80000000", 1 },
{ 16, "-80000000", "-0x80000000", 0 },
{ 16, "-80000001", "-0x80000000", -1 },
{ 16, "-FF0080000001", "-0x80000000", -1 },
{ 16, "0", "-0x8000000000000000", 1 },
{ 16, "8000000000000000", "-0x8000000000000000", 1 },
{ 16, "8000000000000001", "-0x8000000000000000", 1 },
{ 16, "-8000000000000000", "-0x8000000000000000", 0 },
{ 16, "-8000000000000001", "-0x8000000000000000", -1 },
{ 16, "-FF008000000000000001", "-0x8000000000000000", -1 },
};
mpf_t a;
mpz_t bz;
long b;
int got;
int i;
mpf_init (a);
mpz_init (bz);
for (i = 0; i < numberof (data); i++)
{
mpf_set_str_or_abort (a, data[i].a, data[i].a_base);
mpz_set_str_or_abort (bz, data[i].b, 0);
if (mpz_fits_slong_p (bz))
{
b = mpz_get_si (bz);
got = mpf_cmp_si (a, b);
if (SGN (got) != data[i].want)
{
printf ("mpf_cmp_si wrong on data[%d]\n", i);
printf (" a="); mpf_out_str (stdout, 10, 0, a);
printf (" (%s)\n", data[i].a);
printf (" b=%ld (%s)\n", b, data[i].b);
printf (" got=%d\n", got);
printf (" want=%d\n", data[i].want);
abort();
}
}
}
mpf_clear (a);
mpz_clear (bz);
}
int
main (int argc, char **argv)
{
mpz_t op1, op2;
mp_size_t size;
int i;
int reps = 10000;
char *str, *buf;
int base;
gmp_randstate_ptr rands;
mpz_t bs;
unsigned long bsi, size_range;
tests_start ();
rands = RANDS;
mpz_init (bs);
if (argc == 2)
reps = atoi (argv[1]);
mpz_init (op1);
mpz_init (op2);
for (i = 0; i < reps; i++)
{
/* 1. Generate random mpz_t and convert to a string and back to mpz_t
again. */
mpz_urandomb (bs, rands, 32);
size_range = mpz_get_ui (bs) % 12 + 2; /* 2..13 */
mpz_urandomb (bs, rands, size_range); /* 3..8191 bits */
size = mpz_get_ui (bs);
mpz_rrandomb (op1, rands, size);
mpz_urandomb (bs, rands, 1);
bsi = mpz_get_ui (bs);
if ((bsi & 1) != 0)
mpz_neg (op1, op1);
mpz_urandomb (bs, rands, 32);
bsi = mpz_get_ui (bs);
base = bsi % 62 + 1;
if (base == 1)
base = 0;
str = mpz_get_str ((char *) 0, base, op1);
mpz_set_str_or_abort (op2, str, base);
if (mpz_cmp (op1, op2))
{
fprintf (stderr, "ERROR, op1 and op2 different in test %d\n", i);
fprintf (stderr, "str = %s\n", str);
fprintf (stderr, "base = %d\n", base);
fprintf (stderr, "op1 = ");
debug_mp (op1, -16);
fprintf (stderr, "op2 = ");
debug_mp (op2, -16);
abort ();
}
(*__gmp_free_func) (str, strlen (str) + 1);
#if 0
/* 2. Generate random string and convert to mpz_t and back to a string
again. */
mpz_urandomb (bs, rands, 32);
size_range = mpz_get_ui (bs) % 10 + 2; /* 2..11 */
mpz_urandomb (bs, rands, size_range); /* 3..2047 bits */
len = mpz_get_ui (bs);
buf = (*__gmp_allocate_func) (len + 1);
string_urandomb (buf, len, base);
mpz_set_str_or_abort (op1, buf, base);
str = mpz_get_str ((char *) 0, base, op1);
if (strcmp (str, buf) != 0)
{
fprintf (stderr, "ERROR, str and buf different\n");
fprintf (stderr, "str = %s\n", str);
fprintf (stderr, "buf = %s\n", buf);
fprintf (stderr, "base = %d\n", base);
fprintf (stderr, "op1 = ");
debug_mp (op1, -16);
abort ();
}
(*__gmp_free_func) (buf, len + 1);
(*__gmp_free_func) (str, strlen (str) + 1);
#endif
}
mpz_clear (bs);
mpz_clear (op1);
mpz_clear (op2);
tests_end ();
exit (0);
}
void
check_z (void)
{
static const struct {
const char *fmt;
const char *input;
const char *want;
int want_ret;
long want_ftell;
int want_upto;
int not_glibc;
} data[] = {
{ "%Zd", "0", "0", 1, -1, -1 },
{ "%Zd", "1", "1", 1, -1, -1 },
{ "%Zd", "123", "123", 1, -1, -1 },
{ "%Zd", "+0", "0", 1, -1, -1 },
{ "%Zd", "+1", "1", 1, -1, -1 },
{ "%Zd", "+123", "123", 1, -1, -1 },
{ "%Zd", "-0", "0", 1, -1, -1 },
{ "%Zd", "-1", "-1", 1, -1, -1 },
{ "%Zd", "-123", "-123", 1, -1, -1 },
{ "%Zo", "0", "0", 1, -1, -1 },
{ "%Zo", "173", "123", 1, -1, -1 },
{ "%Zo", "+0", "0", 1, -1, -1 },
{ "%Zo", "+173", "123", 1, -1, -1 },
{ "%Zo", "-0", "0", 1, -1, -1 },
{ "%Zo", "-173", "-123", 1, -1, -1 },
{ "%Zx", "0", "0", 1, -1, -1 },
{ "%Zx", "7b", "123", 1, -1, -1 },
{ "%Zx", "7b", "123", 1, -1, -1 },
{ "%Zx", "+0", "0", 1, -1, -1 },
{ "%Zx", "+7b", "123", 1, -1, -1 },
{ "%Zx", "+7b", "123", 1, -1, -1 },
{ "%Zx", "-0", "-0", 1, -1, -1 },
{ "%Zx", "-7b", "-123", 1, -1, -1 },
{ "%Zx", "-7b", "-123", 1, -1, -1 },
{ "%ZX", "0", "0", 1, -1, -1 },
{ "%ZX", "7b", "123", 1, -1, -1 },
{ "%ZX", "7b", "123", 1, -1, -1 },
{ "%ZX", "+0", "0", 1, -1, -1 },
{ "%ZX", "+7b", "123", 1, -1, -1 },
{ "%ZX", "+7b", "123", 1, -1, -1 },
{ "%ZX", "-0", "-0", 1, -1, -1 },
{ "%ZX", "-7b", "-123", 1, -1, -1 },
{ "%ZX", "-7b", "-123", 1, -1, -1 },
{ "%Zx", "0", "0", 1, -1, -1 },
{ "%Zx", "7B", "123", 1, -1, -1 },
{ "%Zx", "7B", "123", 1, -1, -1 },
{ "%Zx", "+0", "0", 1, -1, -1 },
{ "%Zx", "+7B", "123", 1, -1, -1 },
{ "%Zx", "+7B", "123", 1, -1, -1 },
{ "%Zx", "-0", "-0", 1, -1, -1 },
{ "%Zx", "-7B", "-123", 1, -1, -1 },
{ "%Zx", "-7B", "-123", 1, -1, -1 },
{ "%ZX", "0", "0", 1, -1, -1 },
{ "%ZX", "7B", "123", 1, -1, -1 },
{ "%ZX", "7B", "123", 1, -1, -1 },
{ "%ZX", "+0", "0", 1, -1, -1 },
{ "%ZX", "+7B", "123", 1, -1, -1 },
{ "%ZX", "+7B", "123", 1, -1, -1 },
{ "%ZX", "-0", "-0", 1, -1, -1 },
{ "%ZX", "-7B", "-123", 1, -1, -1 },
{ "%ZX", "-7B", "-123", 1, -1, -1 },
{ "%Zi", "0", "0", 1, -1, -1 },
{ "%Zi", "1", "1", 1, -1, -1 },
{ "%Zi", "123", "123", 1, -1, -1 },
{ "%Zi", "+0", "0", 1, -1, -1 },
{ "%Zi", "+1", "1", 1, -1, -1 },
{ "%Zi", "+123", "123", 1, -1, -1 },
{ "%Zi", "-0", "0", 1, -1, -1 },
{ "%Zi", "-1", "-1", 1, -1, -1 },
{ "%Zi", "-123", "-123", 1, -1, -1 },
{ "%Zi", "00", "0", 1, -1, -1 },
{ "%Zi", "0173", "123", 1, -1, -1 },
{ "%Zi", "+00", "0", 1, -1, -1 },
{ "%Zi", "+0173", "123", 1, -1, -1 },
{ "%Zi", "-00", "0", 1, -1, -1 },
{ "%Zi", "-0173", "-123", 1, -1, -1 },
{ "%Zi", "0x0", "0", 1, -1, -1 },
{ "%Zi", "0x7b", "123", 1, -1, -1 },
{ "%Zi", "0x7b", "123", 1, -1, -1 },
{ "%Zi", "+0x0", "0", 1, -1, -1 },
{ "%Zi", "+0x7b", "123", 1, -1, -1 },
{ "%Zi", "+0x7b", "123", 1, -1, -1 },
{ "%Zi", "-0x0", "-0", 1, -1, -1 },
{ "%Zi", "-0x7b", "-123", 1, -1, -1 },
{ "%Zi", "-0x7b", "-123", 1, -1, -1 },
{ "%Zi", "0X0", "0", 1, -1, -1 },
{ "%Zi", "0X7b", "123", 1, -1, -1 },
{ "%Zi", "0X7b", "123", 1, -1, -1 },
{ "%Zi", "+0X0", "0", 1, -1, -1 },
{ "%Zi", "+0X7b", "123", 1, -1, -1 },
{ "%Zi", "+0X7b", "123", 1, -1, -1 },
{ "%Zi", "-0X0", "-0", 1, -1, -1 },
{ "%Zi", "-0X7b", "-123", 1, -1, -1 },
{ "%Zi", "-0X7b", "-123", 1, -1, -1 },
{ "%Zi", "0x0", "0", 1, -1, -1 },
{ "%Zi", "0x7B", "123", 1, -1, -1 },
{ "%Zi", "0x7B", "123", 1, -1, -1 },
{ "%Zi", "+0x0", "0", 1, -1, -1 },
{ "%Zi", "+0x7B", "123", 1, -1, -1 },
{ "%Zi", "+0x7B", "123", 1, -1, -1 },
{ "%Zi", "-0x0", "-0", 1, -1, -1 },
{ "%Zi", "-0x7B", "-123", 1, -1, -1 },
{ "%Zi", "-0x7B", "-123", 1, -1, -1 },
{ "%Zi", "0X0", "0", 1, -1, -1 },
{ "%Zi", "0X7B", "123", 1, -1, -1 },
{ "%Zi", "0X7B", "123", 1, -1, -1 },
{ "%Zi", "+0X0", "0", 1, -1, -1 },
{ "%Zi", "+0X7B", "123", 1, -1, -1 },
{ "%Zi", "+0X7B", "123", 1, -1, -1 },
{ "%Zi", "-0X0", "-0", 1, -1, -1 },
{ "%Zi", "-0X7B", "-123", 1, -1, -1 },
{ "%Zi", "-0X7B", "-123", 1, -1, -1 },
{ "%Zd", " 0", "0", 1, -1, -1 },
{ "%Zd", " 0", "0", 1, -1, -1 },
{ "%Zd", " 0", "0", 1, -1, -1 },
{ "%Zd", "\t0", "0", 1, -1, -1 },
{ "%Zd", "\t\t0", "0", 1, -1, -1 },
{ "hello%Zd", "hello0", "0", 1, -1, -1 },
{ "hello%Zd", "hello 0", "0", 1, -1, -1 },
{ "hello%Zd", "hello \t0", "0", 1, -1, -1 },
{ "hello%Zdworld", "hello 0world", "0", 1, -1, -1 },
{ "hello%*Zd", "hello0", "-999", 0, -1, -1 },
{ "hello%*Zd", "hello 0", "-999", 0, -1, -1 },
{ "hello%*Zd", "hello \t0", "-999", 0, -1, -1 },
{ "hello%*Zdworld", "hello 0world", "-999", 0, -1, -1 },
{ "%Zd", "", "-999", -1, -1, -555 },
{ "%Zd", " ", "-999", -1, -1, -555 },
{ " %Zd", "", "-999", -1, -1, -555 },
{ "xyz%Zd", "", "-999", -1, -1, -555 },
{ "%*Zd", "", "-999", -1, -1, -555 },
{ " %*Zd", "", "-999", -1, -1, -555 },
{ "xyz%*Zd", "", "-999", -1, -1, -555 },
{ "%Zd", "xyz", "0", 0, 0, -555 },
/* match something, but invalid */
{ "%Zd", "-", "-999", 0, 1, -555 },
{ "%Zd", "+", "-999", 0, 1, -555 },
{ "xyz%Zd", "xyz-", "-999", 0, 4, -555 },
{ "xyz%Zd", "xyz+", "-999", 0, 4, -555 },
{ "%Zi", "0x", "-999", 0, 2, -555 },
{ "%Zi", "0X", "-999", 0, 2, -555 },
{ "%Zi", "0x-", "-999", 0, 2, -555 },
{ "%Zi", "0X+", "-999", 0, 2, -555 },
{ "%Zi", "-0x", "-999", 0, 3, -555 },
{ "%Zi", "-0X", "-999", 0, 3, -555 },
{ "%Zi", "+0x", "-999", 0, 3, -555 },
{ "%Zi", "+0X", "-999", 0, 3, -555 },
{ "%1Zi", "1234", "1", 1, 1, 1 },
{ "%2Zi", "1234", "12", 1, 2, 2 },
{ "%3Zi", "1234", "123", 1, 3, 3 },
{ "%4Zi", "1234", "1234", 1, 4, 4 },
{ "%5Zi", "1234", "1234", 1, 4, 4 },
{ "%6Zi", "1234", "1234", 1, 4, 4 },
{ "%1Zi", "01234", "0", 1, 1, 1 },
{ "%2Zi", "01234", "01", 1, 2, 2 },
{ "%3Zi", "01234", "012", 1, 3, 3 },
{ "%4Zi", "01234", "0123", 1, 4, 4 },
{ "%5Zi", "01234", "01234", 1, 5, 5 },
{ "%6Zi", "01234", "01234", 1, 5, 5 },
{ "%7Zi", "01234", "01234", 1, 5, 5 },
{ "%1Zi", "0x1234", "0", 1, 1, 1 },
{ "%2Zi", "0x1234", "-999", 0, 2, -555 },
{ "%3Zi", "0x1234", "0x1", 1, 3, 3 },
{ "%4Zi", "0x1234", "0x12", 1, 4, 4 },
{ "%5Zi", "0x1234", "0x123", 1, 5, 5 },
{ "%6Zi", "0x1234", "0x1234", 1, 6, 6 },
{ "%7Zi", "0x1234", "0x1234", 1, 6, 6 },
{ "%8Zi", "0x1234", "0x1234", 1, 6, 6 },
{ "%%xyz%Zd", "%xyz123", "123", 1, -1, -1 },
{ "12%%34%Zd", "12%34567", "567", 1, -1, -1 },
{ "%%%%%Zd", "%%123", "123", 1, -1, -1 },
/* various subtle EOF cases */
{ "x", "", "-999", EOF, 0, -555 },
{ " x", "", "-999", EOF, 0, -555 },
{ "xyz", "", "-999", EOF, 0, -555 },
{ " ", "", "-999", 0, 0, 0 },
{ " ", " ", "-999", 0, 1, 1 },
{ "%*Zd%Zd", "", "-999", EOF, 0, -555 },
{ "%*Zd%Zd", "123", "-999", EOF, 3, -555 },
{ "x", "x", "-999", 0, 1, 1 },
{ "xyz", "x", "-999", EOF, 1, -555 },
{ "xyz", "xy", "-999", EOF, 2, -555 },
{ "xyz", "xyz", "-999", 0, 3, 3 },
{ "%Zn", "", "0", 0, 0, 0 },
{ " %Zn", "", "0", 0, 0, 0 },
{ " x%Zn", "", "-999", EOF, 0, -555 },
{ "xyz%Zn", "", "-999", EOF, 0, -555 },
{ " x%Zn", "", "-999", EOF, 0, -555 },
{ " %Zn x", " ", "-999", EOF, 1, -555 },
/* these seem to tickle a bug in glibc 2.2.4 */
{ " x", " ", "-999", EOF, 1, -555, 1 },
{ " xyz", " ", "-999", EOF, 1, -555, 1 },
{ " x%Zn", " ", "-999", EOF, 1, -555, 1 },
};
int i, j, ignore;
int got_ret, want_ret, got_upto, want_upto;
mpz_t got, want;
long got_l, want_ftell;
int error = 0;
fun_t fun;
const char *name;
char fmt[128];
mpz_init (got);
mpz_init (want);
for (i = 0; i < numberof (data); i++)
{
mpz_set_str_or_abort (want, data[i].want, 0);
ASSERT_ALWAYS (strlen (data[i].fmt) + 2 < sizeof (fmt));
strcpy (fmt, data[i].fmt);
strcat (fmt, "%n");
ignore = fmt_allignore (fmt);
for (j = 0; j <= 3; j++)
{
want_ret = data[i].want_ret;
want_ftell = data[i].want_ftell;
if (want_ftell == -1)
want_ftell = strlen (data[i].input);
want_upto = data[i].want_upto;
if (want_upto == -1)
want_upto = strlen (data[i].input);
switch (j) {
case 0:
name = "gmp_sscanf";
fun = fun_gmp_sscanf;
break;
case 1:
name = "gmp_fscanf";
fun = fun_gmp_fscanf;
break;
case 2:
#ifdef __GLIBC__
if (data[i].not_glibc)
continue;
#endif
if (! libc_scanf_convert (fmt))
continue;
name = "standard sscanf";
fun = fun_sscanf;
break;
case 3:
#ifdef __GLIBC__
if (data[i].not_glibc)
continue;
#endif
if (! libc_scanf_convert (fmt))
continue;
name = "standard fscanf";
fun = fun_fscanf;
break;
default:
ASSERT_ALWAYS (0);
break;
}
got_upto = -555;
got_ftell = -1L;
switch (j) {
case 0:
case 1:
mpz_set_si (got, -999L);
if (ignore)
got_ret = (*fun) (data[i].input, fmt, &got_upto, NULL);
else
got_ret = (*fun) (data[i].input, fmt, got, &got_upto);
break;
case 2:
case 3:
got_l = -999L;
if (ignore)
got_ret = (*fun) (data[i].input, fmt, &got_upto, NULL);
else
got_ret = (*fun) (data[i].input, fmt, &got_l, &got_upto);
mpz_set_si (got, got_l);
break;
default:
ASSERT_ALWAYS (0);
break;
}
MPZ_CHECK_FORMAT (got);
if (got_ret != want_ret)
{
printf ("%s wrong return value\n", name);
error = 1;
}
if (want_ret == 1 && mpz_cmp (want, got) != 0)
{
printf ("%s wrong result\n", name);
error = 1;
}
if (got_upto != want_upto)
{
printf ("%s wrong upto\n", name);
error = 1;
}
if (got_ftell != -1 && want_ftell != -1 && got_ftell != want_ftell)
{
printf ("%s wrong ftell\n", name);
error = 1;
}
if (error)
{
printf (" fmt \"%s\"\n", data[i].fmt);
printf (" input \"%s\"\n", data[i].input);
printf (" ignore %d\n", ignore);
printf (" ret want=%d\n", want_ret);
printf (" got =%d\n", got_ret);
mpz_trace (" value want", want);
mpz_trace (" got ", got);
printf (" upto want =%d\n", want_upto);
printf (" got =%d\n", got_upto);
if (got_ftell != -1)
{
printf (" ftell want =%ld\n", want_ftell);
printf (" got =%ld\n", got_ftell);
}
abort ();
}
}
}
mpz_clear (got);
mpz_clear (want);
}
void
check_z (void)
{
static const struct {
const char *fmt;
const char *z;
const char *want;
} data[] = {
{ "%Zd", "0", "0" },
{ "%Zd", "1", "1" },
{ "%Zd", "123", "123" },
{ "%Zd", "-1", "-1" },
{ "%Zd", "-123", "-123" },
{ "%+Zd", "0", "+0" },
{ "%+Zd", "123", "+123" },
{ "%+Zd", "-123", "-123" },
{ "%Zx", "123", "7b" },
{ "%ZX", "123", "7B" },
{ "%Zx", "-123", "-7b" },
{ "%ZX", "-123", "-7B" },
{ "%Zo", "123", "173" },
{ "%Zo", "-123", "-173" },
{ "%#Zx", "0", "0" },
{ "%#ZX", "0", "0" },
{ "%#Zx", "123", "0x7b" },
{ "%#ZX", "123", "0X7B" },
{ "%#Zx", "-123", "-0x7b" },
{ "%#ZX", "-123", "-0X7B" },
{ "%#Zo", "0", "0" },
{ "%#Zo", "123", "0173" },
{ "%#Zo", "-123", "-0173" },
{ "%10Zd", "0", " 0" },
{ "%10Zd", "123", " 123" },
{ "%10Zd", "-123", " -123" },
{ "%-10Zd", "0", "0 " },
{ "%-10Zd", "123", "123 " },
{ "%-10Zd", "-123", "-123 " },
{ "%+10Zd", "123", " +123" },
{ "%+-10Zd", "123", "+123 " },
{ "%+10Zd", "-123", " -123" },
{ "%+-10Zd", "-123", "-123 " },
{ "%08Zd", "0", "00000000" },
{ "%08Zd", "123", "00000123" },
{ "%08Zd", "-123", "-0000123" },
{ "%+08Zd", "0", "+0000000" },
{ "%+08Zd", "123", "+0000123" },
{ "%+08Zd", "-123", "-0000123" },
{ "%#08Zx", "0", "00000000" },
{ "%#08Zx", "123", "0x00007b" },
{ "%#08Zx", "-123", "-0x0007b" },
{ "%+#08Zx", "0", "+0000000" },
{ "%+#08Zx", "123", "+0x0007b" },
{ "%+#08Zx", "-123", "-0x0007b" },
{ "%.0Zd", "0", "" },
{ "%.1Zd", "0", "0" },
{ "%.2Zd", "0", "00" },
{ "%.3Zd", "0", "000" },
};
int i, j;
mpz_t z;
char *nfmt;
mp_size_t nsize, zeros;
mpz_init (z);
for (i = 0; i < numberof (data); i++)
{
mpz_set_str_or_abort (z, data[i].z, 0);
/* don't try negatives or forced sign in hex or octal */
if (mpz_fits_slong_p (z)
&& ! (hex_or_octal_p (data[i].fmt)
&& (strchr (data[i].fmt, '+') != NULL || mpz_sgn(z) < 0)))
{
check_plain (data[i].want, data[i].fmt, mpz_get_si (z));
}
check_one (data[i].want, data[i].fmt, z);
/* Same again, with %N and possibly some high zero limbs */
nfmt = __gmp_allocate_strdup (data[i].fmt);
for (j = 0; nfmt[j] != '\0'; j++)
if (nfmt[j] == 'Z')
nfmt[j] = 'N';
for (zeros = 0; zeros <= 3; zeros++)
{
nsize = ABSIZ(z)+zeros;
MPZ_REALLOC (z, nsize);
nsize = (SIZ(z) >= 0 ? nsize : -nsize);
refmpn_zero (PTR(z)+ABSIZ(z), zeros);
check_one (data[i].want, nfmt, PTR(z), nsize);
}
__gmp_free_func (nfmt, strlen(nfmt)+1);
}
mpz_clear (z);
}
void
check_data (void)
{
static const struct {
const char *want;
size_t count;
int order;
size_t size;
int endian;
int nail;
char src[64];
} data[] = {
{ "0", 0,1, 1,1, 0 },
{ "0", 1,1, 0,1, 0 },
{ "0x12345678", 4,1, 1,1, 0, { '\22', '\64', '\126', '\170' } },
{ "0x12345678", 1,1, 4,1, 0, { '\22', '\64', '\126', '\170' } },
{ "0x12345678", 1,-1, 4,1, 0, { '\22', '\64', '\126', '\170' } },
{ "0x12345678", 4,-1, 1,-1, 0, { '\170', '\126', '\064', '\22' } },
{ "0x12345678", 1,1, 4,-1, 0, { '\170', '\126', '\064', '\22' } },
{ "0x12345678", 1,-1, 4,-1, 0, { '\170', '\126', '\064', '\22' } },
{ "0", 5,1, 1,1, 7, { '\376', '\376', '\376', '\376', '\376' } },
{ "0", 5,-1, 1,1, 7, { '\376', '\376', '\376', '\376', '\376' } },
{ "0x15", 5,1, 1,1, 7, { '\377', '\376', '\377', '\376', '\377' } },
{ "0", 3,1, 2,1, 1, { '\200','\000', '\200','\000', '\200','\000' }},
{ "0", 3,1, 2,-1, 1, { '\000','\200', '\000','\200', '\000','\200' }},
{ "0", 3,1, 2,1, 15, { '\377','\376', '\377','\376', '\377','\376' }},
{ "0x2A", 3,1, 2,1, 14, { '\377','\376', '\377','\376', '\377','\376' } },
{ "0x06", 3,1, 2,1, 14, { '\377','\374', '\377','\375', '\377','\376' } },
{ "0x24", 3,-1, 2,1, 14, { '\377','\374', '\377','\375', '\377','\376' } },
{ "0x123456789ABC", 3,1, 2,1, 0, {
'\022','\064', '\126','\170', '\232','\274' } },
{ "0x123456789ABC", 3,-1, 2,1, 0, {
'\232','\274', '\126','\170', '\022','\064' } },
{ "0x123456789ABC", 3,1, 2,-1, 0, {
'\064','\022', '\170','\126', '\274','\232' } },
{ "0x123456789ABC", 3,-1, 2,-1, 0, {
'\274','\232', '\170','\126', '\064','\022' } },
{ "0x112233445566778899AABBCC", 3,1, 4,1, 0,
{ '\021','\042','\063','\104',
'\125','\146','\167','\210',
'\231','\252','\273','\314' } },
{ "0x112233445566778899AABBCC", 3,-1, 4,1, 0,
{ '\231','\252','\273','\314',
'\125','\146','\167','\210',
'\021','\042','\063','\104' } },
{ "0x112233445566778899AABBCC", 3,1, 4,-1, 0,
{ '\104','\063','\042','\021',
'\210','\167','\146','\125',
'\314','\273','\252','\231' } },
{ "0x112233445566778899AABBCC", 3,-1, 4,-1, 0,
{ '\314','\273','\252','\231',
'\210','\167','\146','\125',
'\104','\063','\042','\021' } },
{ "0x100120023003400450056006700780089009A00AB00BC00C", 3,1, 8,1, 0,
{ '\020','\001','\040','\002','\060','\003','\100','\004',
'\120','\005','\140','\006','\160','\007','\200','\010',
'\220','\011','\240','\012','\260','\013','\300','\014' } },
{ "0x100120023003400450056006700780089009A00AB00BC00C", 3,-1, 8,1, 0,
{ '\220','\011','\240','\012','\260','\013','\300','\014',
'\120','\005','\140','\006','\160','\007','\200','\010',
'\020','\001','\040','\002','\060','\003','\100','\004' } },
{ "0x100120023003400450056006700780089009A00AB00BC00C", 3,1, 8,-1, 0,
{ '\004','\100','\003','\060','\002','\040','\001','\020',
'\010','\200','\007','\160','\006','\140','\005','\120',
'\014','\300','\013','\260','\012','\240','\011','\220' } },
{ "0x100120023003400450056006700780089009A00AB00BC00C", 3,-1, 8,-1, 0,
{ '\014','\300','\013','\260','\012','\240','\011','\220',
'\010','\200','\007','\160','\006','\140','\005','\120',
'\004','\100','\003','\060','\002','\040','\001','\020' } },
{ "0x155555555555555555555555", 3,1, 4,1, 1,
{ '\325','\125','\125','\125',
'\252','\252','\252','\252',
'\325','\125','\125','\125' } },
{ "0x155555555555555555555555", 3,-1, 4,1, 1,
{ '\325','\125','\125','\125',
'\252','\252','\252','\252',
'\325','\125','\125','\125' } },
{ "0x155555555555555555555555", 3,1, 4,-1, 1,
{ '\125','\125','\125','\325',
'\252','\252','\252','\252',
'\125','\125','\125','\325' } },
{ "0x155555555555555555555555", 3,-1, 4,-1, 1,
{ '\125','\125','\125','\325',
'\252','\252','\252','\252',
'\125','\125','\125','\325' } },
};
char buf[sizeof(data[0].src) + sizeof (mp_limb_t)];
char *src;
size_t align;
int i;
mpz_t got, want;
mpz_init (got);
mpz_init (want);
for (i = 0; i < numberof (data); i++)
{
for (align = 0; align < sizeof (mp_limb_t); align++)
{
mpz_set_str_or_abort (want, data[i].want, 0);
src = buf + align;
memcpy (src, data[i].src, data[i].count * data[i].size);
mpz_set_ui (got, 0L);
mpz_import (got, data[i].count, data[i].order,
data[i].size, data[i].endian, data[i].nail, src);
MPZ_CHECK_FORMAT (got);
if (mpz_cmp (got, want) != 0)
{
printf ("wrong at data[%d]\n", i);
printf (" count=%lu order=%d size=%lu endian=%d nail=%u align=%lu\n",
(unsigned long) data[i].count, data[i].order,
(unsigned long) data[i].size, data[i].endian, data[i].nail,
(unsigned long) align);
mpz_trace (" got ", got);
mpz_trace (" want", want);
abort ();
}
}
}
mpz_clear (got);
mpz_clear (want);
}
int
main (int argc, char **argv)
{
#if GMP_NAIL_BITS == 0
static const struct {
int f_base;
const char *f;
int z_base;
const char *want_num;
const char *want_den;
} data[] = {
{ -2, "0", 16, "0", "1" },
{ -2, "1", 16, "1", "1" },
{ -2, "1@1", 16, "2", "1" },
{ -2, "1@2", 16, "4", "1" },
{ -2, "1@3", 16, "8", "1" },
{ -2, "1@30", 16, "40000000", "1" },
{ -2, "1@31", 16, "80000000", "1" },
{ -2, "1@32", 16, "100000000", "1" },
{ -2, "1@33", 16, "200000000", "1" },
{ -2, "1@34", 16, "400000000", "1" },
{ -2, "1@62", 16, "4000000000000000", "1" },
{ -2, "1@63", 16, "8000000000000000", "1" },
{ -2, "1@64", 16, "10000000000000000", "1" },
{ -2, "1@65", 16, "20000000000000000", "1" },
{ -2, "1@66", 16, "40000000000000000", "1" },
{ -2, "1@126", 16, "40000000000000000000000000000000", "1" },
{ -2, "1@127", 16, "80000000000000000000000000000000", "1" },
{ -2, "1@128", 16, "100000000000000000000000000000000", "1" },
{ -2, "1@129", 16, "200000000000000000000000000000000", "1" },
{ -2, "1@130", 16, "400000000000000000000000000000000", "1" },
{ -2, "1@-1", 16, "1", "2" },
{ -2, "1@-2", 16, "1", "4" },
{ -2, "1@-3", 16, "1", "8" },
{ -2, "1@-30", 16, "1", "40000000" },
{ -2, "1@-31", 16, "1", "80000000" },
{ -2, "1@-32", 16, "1", "100000000" },
{ -2, "1@-33", 16, "1", "200000000" },
{ -2, "1@-34", 16, "1", "400000000" },
{ -2, "1@-62", 16, "1", "4000000000000000" },
{ -2, "1@-63", 16, "1", "8000000000000000" },
{ -2, "1@-64", 16, "1", "10000000000000000" },
{ -2, "1@-65", 16, "1", "20000000000000000" },
{ -2, "1@-66", 16, "1", "40000000000000000" },
{ -2, "1@-126", 16, "1", "40000000000000000000000000000000" },
{ -2, "1@-127", 16, "1", "80000000000000000000000000000000" },
{ -2, "1@-128", 16, "1", "100000000000000000000000000000000" },
{ -2, "1@-129", 16, "1", "200000000000000000000000000000000" },
{ -2, "1@-130", 16, "1", "400000000000000000000000000000000" },
{ -2, "1@-30", 16, "1", "40000000" },
{ -2, "1@-31", 16, "1", "80000000" },
{ -2, "1@-32", 16, "1", "100000000" },
{ -2, "1@-33", 16, "1", "200000000" },
{ -2, "1@-34", 16, "1", "400000000" },
{ -2, "11@-62", 16, "3", "4000000000000000" },
{ -2, "11@-63", 16, "3", "8000000000000000" },
{ -2, "11@-64", 16, "3", "10000000000000000" },
{ -2, "11@-65", 16, "3", "20000000000000000" },
{ -2, "11@-66", 16, "3", "40000000000000000" },
{ 16, "80000000.00000001", 16, "8000000000000001", "100000000" },
{ 16, "80000000.00000008", 16, "1000000000000001", "20000000" },
{ 16, "80000000.8", 16, "100000001", "2" },
};
mpf_t f;
mpq_t got;
mpz_t want_num, want_den;
int i, neg;
tests_start ();
mpf_init2 (f, 1024L);
mpq_init (got);
mpz_init (want_num);
mpz_init (want_den);
for (i = 0; i < numberof (data); i++)
{
for (neg = 0; neg <= 1; neg++)
{
mpf_set_str_or_abort (f, data[i].f, data[i].f_base);
mpz_set_str_or_abort (want_num, data[i].want_num, data[i].z_base);
mpz_set_str_or_abort (want_den, data[i].want_den, data[i].z_base);
if (neg)
{
mpf_neg (f, f);
mpz_neg (want_num, want_num);
}
mpq_set_f (got, f);
MPQ_CHECK_FORMAT (got);
if (mpz_cmp (mpq_numref(got), want_num) != 0
|| mpz_cmp (mpq_denref(got), want_den) != 0)
{
printf ("wrong at data[%d]\n", i);
printf (" f_base %d, z_base %d\n",
data[i].f_base, data[i].z_base);
printf (" f \"%s\" hex ", data[i].f);
mpf_out_str (stdout, 16, 0, f);
printf ("\n");
printf (" want num 0x");
mpz_out_str (stdout, 16, want_num);
printf ("\n");
printf (" want den 0x");
mpz_out_str (stdout, 16, want_den);
printf ("\n");
printf (" got num 0x");
mpz_out_str (stdout, 16, mpq_numref(got));
printf ("\n");
printf (" got den 0x");
mpz_out_str (stdout, 16, mpq_denref(got));
printf ("\n");
abort ();
}
}
}
mpf_clear (f);
mpq_clear (got);
mpz_clear (want_num);
mpz_clear (want_den);
tests_end ();
#endif
exit (0);
}
void
check_various (void)
{
static const struct {
const char *base;
} data[] = {
{ "0" },
{ "1" },
{ "2" },
{ "3" },
{ "4" },
{ "5" },
{ "6" },
{ "10" },
{ "15" },
{ "16" },
{ "0x1F" },
{ "0xFF" },
{ "0x1001" },
{ "0xFFFF" },
{ "0x10000001" },
{ "0x1000000000000001" },
/* actual size closest to estimate */
{ "0xFFFFFFFF" },
{ "0xFFFFFFFFFFFFFFFF" },
/* same after rshift */
{ "0xFFFFFFFF0" },
{ "0xFFFFFFFF00" },
{ "0xFFFFFFFFFFFFFFFF0" },
{ "0xFFFFFFFFFFFFFFFF00" },
/* change from 2 limbs to 1 after rshift */
{ "0x180000000" },
{ "0x18000000000000000" },
/* change from 3 limbs to 2 after rshift */
{ "0x18000000100000000" },
{ "0x180000000000000010000000000000000" },
/* handling of absolute value */
{ "-0x80000000" },
{ "-0x8000000000000000" },
/* low zero limb, and size>2, checking argument overlap detection */
{ "0x3000000000000000300000000000000030000000000000000" },
};
mpz_t base;
int i;
mpz_init (base);
for (i = 0; i < numberof (data); i++)
{
mpz_set_str_or_abort (base, data[i].base, 0);
check_base (base);
}
mpz_clear (base);
}
void
check_data (void)
{
static const struct {
const char *a;
unsigned long d;
int want;
} data[] = {
{ "0", 0, 1 },
{ "0", 1, 1 },
{ "0", 2, 1 },
{ "0", 3, 1 },
{ "1", 0, 1 },
{ "1", 1, 0 },
{ "1", 2, 0 },
{ "1", 3, 0 },
{ "1", 10000, 0 },
{ "4", 0, 1 },
{ "4", 1, 1 },
{ "4", 2, 1 },
{ "4", 3, 0 },
{ "4", 4, 0 },
{ "4", 10000, 0 },
{ "0x80000000", 31, 1 },
{ "0x80000000", 32, 0 },
{ "0x80000000", 64, 0 },
{ "0x100000000", 32, 1 },
{ "0x100000000", 33, 0 },
{ "0x100000000", 64, 0 },
{ "0x8000000000000000", 63, 1 },
{ "0x8000000000000000", 64, 0 },
{ "0x8000000000000000", 128, 0 },
{ "0x10000000000000000", 64, 1 },
{ "0x10000000000000000", 65, 0 },
{ "0x10000000000000000", 128, 0 },
{ "0x10000000000000000", 256, 0 },
{ "0x10000000000000000100000000", 32, 1 },
{ "0x10000000000000000100000000", 33, 0 },
{ "0x10000000000000000100000000", 64, 0 },
{ "0x1000000000000000010000000000000000", 64, 1 },
{ "0x1000000000000000010000000000000000", 65, 0 },
{ "0x1000000000000000010000000000000000", 128, 0 },
{ "0x1000000000000000010000000000000000", 256, 0 },
{ "0x1000000000000000010000000000000000", 1024, 0 },
};
mpz_t a, d;
int i;
mpz_init (a);
mpz_init (d);
for (i = 0; i < numberof (data); i++)
{
mpz_set_str_or_abort (a, data[i].a, 0);
check_one (a, data[i].d, data[i].want);
mpz_neg (a, a);
check_one (a, data[i].d, data[i].want);
}
mpz_clear (a);
mpz_clear (d);
}
int
main (int argc, char **argv)
{
static const struct {
struct pair_t left;
unsigned long n;
struct pair_t right;
} data[] = {
{ {"0","1"}, 0, {"0","1"} },
{ {"0","1"}, 1, {"0","1"} },
{ {"0","1"}, 2, {"0","1"} },
{ {"1","1"}, 0, {"1","1"} },
{ {"1","1"}, 1, {"2","1"} },
{ {"1","1"}, 2, {"4","1"} },
{ {"1","1"}, 3, {"8","1"} },
{ {"1","1"}, 31, {"0x80000000","1"} },
{ {"1","1"}, 32, {"0x100000000","1"} },
{ {"1","1"}, 33, {"0x200000000","1"} },
{ {"1","1"}, 63, {"0x8000000000000000","1"} },
{ {"1","1"}, 64, {"0x10000000000000000","1"} },
{ {"1","1"}, 65, {"0x20000000000000000","1"} },
{ {"1","1"}, 95, {"0x800000000000000000000000","1"} },
{ {"1","1"}, 96, {"0x1000000000000000000000000","1"} },
{ {"1","1"}, 97, {"0x2000000000000000000000000","1"} },
{ {"1","1"}, 127, {"0x80000000000000000000000000000000","1"} },
{ {"1","1"}, 128, {"0x100000000000000000000000000000000","1"} },
{ {"1","1"}, 129, {"0x200000000000000000000000000000000","1"} },
{ {"1","2"}, 31, {"0x40000000","1"} },
{ {"1","2"}, 32, {"0x80000000","1"} },
{ {"1","2"}, 33, {"0x100000000","1"} },
{ {"1","2"}, 63, {"0x4000000000000000","1"} },
{ {"1","2"}, 64, {"0x8000000000000000","1"} },
{ {"1","2"}, 65, {"0x10000000000000000","1"} },
{ {"1","2"}, 95, {"0x400000000000000000000000","1"} },
{ {"1","2"}, 96, {"0x800000000000000000000000","1"} },
{ {"1","2"}, 97, {"0x1000000000000000000000000","1"} },
{ {"1","2"}, 127, {"0x40000000000000000000000000000000","1"} },
{ {"1","2"}, 128, {"0x80000000000000000000000000000000","1"} },
{ {"1","2"}, 129, {"0x100000000000000000000000000000000","1"} },
{ {"1","0x80000000"}, 30, {"1","2"} },
{ {"1","0x80000000"}, 31, {"1","1"} },
{ {"1","0x80000000"}, 32, {"2","1"} },
{ {"1","0x80000000"}, 33, {"4","1"} },
{ {"1","0x80000000"}, 62, {"0x80000000","1"} },
{ {"1","0x80000000"}, 63, {"0x100000000","1"} },
{ {"1","0x80000000"}, 64, {"0x200000000","1"} },
{ {"1","0x80000000"}, 94, {"0x8000000000000000","1"} },
{ {"1","0x80000000"}, 95, {"0x10000000000000000","1"} },
{ {"1","0x80000000"}, 96, {"0x20000000000000000","1"} },
{ {"1","0x80000000"}, 126, {"0x800000000000000000000000","1"} },
{ {"1","0x80000000"}, 127, {"0x1000000000000000000000000","1"} },
{ {"1","0x80000000"}, 128, {"0x2000000000000000000000000","1"} },
{ {"1","0x100000000"}, 1, {"1","0x80000000"} },
{ {"1","0x100000000"}, 2, {"1","0x40000000"} },
{ {"1","0x100000000"}, 3, {"1","0x20000000"} },
{ {"1","0x10000000000000000"}, 1, {"1","0x8000000000000000"} },
{ {"1","0x10000000000000000"}, 2, {"1","0x4000000000000000"} },
{ {"1","0x10000000000000000"}, 3, {"1","0x2000000000000000"} },
};
void (*fun) (mpq_ptr, mpq_srcptr, unsigned long);
const struct pair_t *p_start, *p_want;
const char *name;
mpq_t sep, got, want;
mpq_ptr q;
int i, muldiv, sign, overlap;
tests_start ();
mpq_init (sep);
mpq_init (got);
mpq_init (want);
for (i = 0; i < numberof (data); i++)
{
for (muldiv = 0; muldiv < 2; muldiv++)
{
if (muldiv == 0)
{
fun = mpq_mul_2exp;
name = "mpq_mul_2exp";
p_start = &data[i].left;
p_want = &data[i].right;
}
else
{
fun = mpq_div_2exp;
name = "mpq_div_2exp";
p_start = &data[i].right;
p_want = &data[i].left;
}
for (sign = 0; sign <= 1; sign++)
{
mpz_set_str_or_abort (mpq_numref(want), p_want->num, 0);
mpz_set_str_or_abort (mpq_denref(want), p_want->den, 0);
if (sign)
mpq_neg (want, want);
for (overlap = 0; overlap <= 1; overlap++)
{
q = overlap ? got : sep;
/* initial garbage in "got" */
mpq_set_ui (got, 123L, 456L);
mpz_set_str_or_abort (mpq_numref(q), p_start->num, 0);
mpz_set_str_or_abort (mpq_denref(q), p_start->den, 0);
if (sign)
mpq_neg (q, q);
(*fun) (got, q, data[i].n);
MPQ_CHECK_FORMAT (got);
if (! mpq_equal (got, want))
{
printf ("%s wrong at data[%d], sign %d, overlap %d\n",
name, i, sign, overlap);
printf (" num \"%s\"\n", p_start->num);
printf (" den \"%s\"\n", p_start->den);
printf (" n %lu\n", data[i].n);
printf (" got ");
mpq_out_str (stdout, 16, got);
printf (" (hex)\n");
printf (" want ");
mpq_out_str (stdout, 16, want);
printf (" (hex)\n");
abort ();
}
}
}
}
}
check_random ();
mpq_clear (sep);
mpq_clear (got);
mpq_clear (want);
tests_end ();
exit (0);
}
void
check_data (void)
{
static const struct {
const char *inp;
int base;
const char *want;
int want_nread;
} data[] = {
{ "0", 10, "0", 1 },
{ "abc", 10, "0", 0 },
{ "0xf", 10, "0", 1 },
{ "ghi", 16, "0", 0 },
{ "100", 90, "0", 0 },
{ "ff", 16, "255", 2 },
{ "-ff", 16, "-255", 3 },
{ "FF", 16, "255", 2 },
{ "-FF", 16, "-255", 3 },
{ "z", 36, "35", 1 },
{ "Z", 36, "35", 1 },
{ "1B", 59, "70", 2 },
{ "a", 60, "36", 1 },
{ "A", 61, "10", 1 },
{ "0x0", 0, "0", 3 },
{ "0X10", 0, "16", 4 },
{ "-0X0", 0, "0", 4 },
{ "-0x10", 0, "-16", 5 },
{ "0b0", 0, "0", 3 },
{ "0B10", 0, "2", 4 },
{ "-0B0", 0, "0", 4 },
{ "-0b10", 0, "-2", 5 },
{ "00", 0, "0", 2 },
{ "010", 0, "8", 3 },
{ "-00", 0, "0", 3 },
{ "-010", 0, "-8", 4 },
{ "0x", 0, "0", 2 },
{ "0", 0, "0", 1 },
{ " 030", 10, "30", 4 },
};
mpz_t got, want;
long ftell_nread;
int i, pre, post, j, got_nread, want_nread;
FILE *fp;
mpz_init (got);
mpz_init (want);
for (i = 0; i < numberof (data); i++)
{
for (pre = 0; pre <= 3; pre++)
{
for (post = 0; post <= 2; post++)
{
mpz_set_str_or_abort (want, data[i].want, 0);
MPZ_CHECK_FORMAT (want);
/* create the file new each time to ensure its length is what
we want */
fp = fopen (FILENAME, "w+");
ASSERT_ALWAYS (fp != NULL);
for (j = 0; j < pre; j++)
putc (' ', fp);
fputs (data[i].inp, fp);
for (j = 0; j < post; j++)
putc (' ', fp);
fflush (fp);
ASSERT_ALWAYS (! ferror(fp));
rewind (fp);
got_nread = mpz_inp_str (got, fp, data[i].base);
if (got_nread != 0)
{
ftell_nread = ftell (fp);
if (got_nread != ftell_nread)
{
printf ("mpz_inp_str nread wrong\n");
printf (" inp \"%s\"\n", data[i].inp);
printf (" base %d\n", data[i].base);
printf (" pre %d\n", pre);
printf (" post %d\n", post);
printf (" got_nread %d\n", got_nread);
printf (" ftell_nread %ld\n", ftell_nread);
abort ();
}
}
/* if data[i].inp is a whole string to read and there's no post
whitespace then expect to have EOF */
if (post == 0 && data[i].want_nread == strlen(data[i].inp))
{
int c = getc(fp);
if (c != EOF)
{
printf ("mpz_inp_str didn't read to EOF\n");
printf (" inp \"%s\"\n", data[i].inp);
printf (" base %d\n", data[i].base);
printf (" pre %d\n", pre);
printf (" post %d\n", post);
printf (" c '%c' %#x\n", c, c);
abort ();
}
}
/* only expect "pre" included in the count when non-zero */
want_nread = data[i].want_nread;
if (want_nread != 0)
want_nread += pre;
if (got_nread != want_nread)
{
printf ("mpz_inp_str nread wrong\n");
printf (" inp \"%s\"\n", data[i].inp);
printf (" base %d\n", data[i].base);
printf (" pre %d\n", pre);
printf (" post %d\n", post);
printf (" got_nread %d\n", got_nread);
printf (" want_nread %d\n", want_nread);
abort ();
}
MPZ_CHECK_FORMAT (got);
if (mpz_cmp (got, want) != 0)
{
printf ("mpz_inp_str wrong result\n");
printf (" inp \"%s\"\n", data[i].inp);
printf (" base %d\n", data[i].base);
mpz_trace (" got ", got);
mpz_trace (" want", want);
abort ();
}
ASSERT_ALWAYS (fclose (fp) == 0);
}
}
}
mpz_clear (got);
mpz_clear (want);
}
