mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-06-29 09:28:45 +00:00
Code Activity

ensure that assertions within the unit tests are exercised in all build modes, remove special handling of SASSERT for release mode #1163

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2017-07-26 20:28:55 -07:00
parent 3f8b63f5a8
commit b1298d7bde
67 changed files with 1277 additions and 1285 deletions
Download patch file Download diff file Expand all files Collapse all files

238
src/test/mpff.cpp
View file

@ -77,10 +77,10 @@ static void tst5() {
scoped_mpff a(m), b(m);
m.set(a, static_cast<uint64>(1) << 63);
m.display_raw(std::cout, a); std::cout << "\n";
SASSERT(m.is_zero(b));
SASSERT(m.lt(b, a));
ENSURE(m.is_zero(b));
ENSURE(m.lt(b, a));
m.set(b, -1);
SASSERT(m.lt(b, a));
ENSURE(m.lt(b, a));
}
static void tst6() {
@ -90,10 +90,10 @@ static void tst6() {
std::cout << "mpff(1/3) " << a << "\n";
b = a;
m.next(b);
SASSERT(m.lt(a, b));
ENSURE(m.lt(a, b));
std::cout << "b: " << b << "\n";
m.prev(b);
SASSERT(m.eq(a, b));
ENSURE(m.eq(a, b));
m.ceil(b);
std::cout << "b: " << b << "\n";
m.set(b, 4, 3);
@ -135,15 +135,15 @@ static void tst_ ## OP ## _core(int64 n1, uint64 d1, int64 n2, uint64 d2, unsign
fm.round_to_plus_inf(); \
fm.OP(fa, fb, fc1); \
fm.to_mpq(fc1, qm, qt); \
SASSERT(qm.le(qc, qt)); \
ENSURE(qm.le(qc, qt)); \
} \
{ \
fm.round_to_minus_inf(); \
fm.OP(fa, fb, fc2); \
fm.to_mpq(fc2, qm, qt); \
SASSERT(qm.le(qt, qc)); \
ENSURE(qm.le(qt, qc)); \
} \
SASSERT(fm.le(fc2, fc1)); \
ENSURE(fm.le(fc2, fc1)); \
}
MK_BIN_OP(add);
@ -182,7 +182,7 @@ static void tst_bug() {
scoped_mpq b(qm), c(qm);
qm.set(b, 41, 36);
fm.to_mpq(a, qm, c);
SASSERT(qm.le(b, c));
ENSURE(qm.le(b, c));
}
static void tst_bug2() {
@ -191,16 +191,16 @@ static void tst_bug2() {
fm.set(b, 1);
fm.sub(a, b, b);
fm.set(a, -1);
SASSERT(fm.eq(a, b));
ENSURE(fm.eq(a, b));
fm.set(a, 1);
fm.set(b, 0);
fm.sub(a, b, a);
fm.set(b, 1);
SASSERT(fm.eq(a, b));
ENSURE(fm.eq(a, b));
fm.set(a, 1);
fm.set(b, 1);
fm.sub(a, b, a);
SASSERT(fm.is_zero(a));
ENSURE(fm.is_zero(a));
}
static void tst_set64(unsigned N, unsigned prec) {
@ -208,69 +208,69 @@ static void tst_set64(unsigned N, unsigned prec) {
scoped_mpff a(fm);
fm.set(a, static_cast<int64>(INT64_MAX));
SASSERT(fm.is_int64(a));
SASSERT(fm.is_uint64(a));
ENSURE(fm.is_int64(a));
ENSURE(fm.is_uint64(a));
fm.inc(a);
SASSERT(!fm.is_int64(a));
SASSERT(fm.is_uint64(a));
SASSERT(fm.is_int(a));
ENSURE(!fm.is_int64(a));
ENSURE(fm.is_uint64(a));
ENSURE(fm.is_int(a));
fm.dec(a);
SASSERT(fm.is_int64(a));
SASSERT(fm.is_uint64(a));
ENSURE(fm.is_int64(a));
ENSURE(fm.is_uint64(a));
fm.dec(a);
SASSERT(fm.is_int64(a));
SASSERT(fm.is_uint64(a));
ENSURE(fm.is_int64(a));
ENSURE(fm.is_uint64(a));
fm.set(a, static_cast<int64>(INT64_MIN));
SASSERT(fm.is_int64(a));
SASSERT(!fm.is_uint64(a));
ENSURE(fm.is_int64(a));
ENSURE(!fm.is_uint64(a));
fm.dec(a);
SASSERT(!fm.is_int64(a));
SASSERT(!fm.is_uint64(a));
SASSERT(fm.is_int(a));
ENSURE(!fm.is_int64(a));
ENSURE(!fm.is_uint64(a));
ENSURE(fm.is_int(a));
fm.inc(a);
SASSERT(fm.is_int64(a));
SASSERT(!fm.is_uint64(a));
ENSURE(fm.is_int64(a));
ENSURE(!fm.is_uint64(a));
fm.inc(a);
SASSERT(fm.is_int64(a));
SASSERT(!fm.is_uint64(a));
ENSURE(fm.is_int64(a));
ENSURE(!fm.is_uint64(a));
fm.set(a, static_cast<uint64>(UINT64_MAX));
SASSERT(fm.is_uint64(a));
SASSERT(!fm.is_int64(a));
ENSURE(fm.is_uint64(a));
ENSURE(!fm.is_int64(a));
fm.inc(a);
SASSERT(!fm.is_uint64(a));
SASSERT(!fm.is_int64(a));
ENSURE(!fm.is_uint64(a));
ENSURE(!fm.is_int64(a));
fm.dec(a);
SASSERT(fm.is_uint64(a));
SASSERT(!fm.is_int64(a));
ENSURE(fm.is_uint64(a));
ENSURE(!fm.is_int64(a));
fm.dec(a);
SASSERT(fm.is_uint64(a));
SASSERT(!fm.is_int64(a));
ENSURE(fm.is_uint64(a));
ENSURE(!fm.is_int64(a));
for (unsigned i = 0; i < N; i++) {
{
uint64 v = (static_cast<uint64>(rand()) << 32) + static_cast<uint64>(rand());
fm.set(a, v);
SASSERT(fm.is_uint64(a));
ENSURE(fm.is_uint64(a));
v = (static_cast<uint64>(rand() % 3) << 32) + static_cast<uint64>(rand());
fm.set(a, v);
SASSERT(fm.is_uint64(a));
ENSURE(fm.is_uint64(a));
}
{
int64 v = (static_cast<uint64>(rand() % INT_MAX) << 32) + static_cast<uint64>(rand());
if (rand()%2 == 0)
v = -v;
fm.set(a, v);
SASSERT(fm.is_int64(a));
ENSURE(fm.is_int64(a));
v = (static_cast<uint64>(rand() % 3) << 32) + static_cast<uint64>(rand());
if (rand()%2 == 0)
v = -v;
fm.set(a, v);
SASSERT(fm.is_int64(a));
ENSURE(fm.is_int64(a));
}
}
}
@ -282,12 +282,12 @@ static void tst_capacity(unsigned prec = 2) {
for (unsigned i = 0; i < 50000; i++) {
m.set(a, i);
v.push_back(a);
SASSERT(m.is_int(v.back()));
SASSERT(m.is_int64(v.back()));
SASSERT(m.is_uint64(v.back()));
ENSURE(m.is_int(v.back()));
ENSURE(m.is_int64(v.back()));
ENSURE(m.is_uint64(v.back()));
}
for (unsigned i = 0; i < 50000; i++) {
SASSERT(m.get_int64(v[i]) == i);
ENSURE(m.get_int64(v[i]) == i);
}
}
@ -296,140 +296,140 @@ static void tst_power(unsigned prec = 2) {
scoped_mpff a(m), b(m);
// 0^k == 0
SASSERT(m.is_zero(a));
ENSURE(m.is_zero(a));
m.power(a, 10, a);
SASSERT(m.is_zero(a));
ENSURE(m.is_zero(a));
// a != 0 ==> a^0 == 1
m.set(a, 33);
m.power(a, 0, a);
SASSERT(m.is_one(a));
ENSURE(m.is_one(a));
m.set(a, -33);
m.power(a, 0, a);
SASSERT(m.is_one(a));
ENSURE(m.is_one(a));
// a^1 == a
m.set(a, 33);
m.power(a, 1, b);
SASSERT(m.eq(a, b));
ENSURE(m.eq(a, b));
m.set(a, -33);
m.power(a, 1, b);
SASSERT(m.eq(a, b));
ENSURE(m.eq(a, b));
// checking special support for powers of 2
#ifdef Z3DEBUG
unsigned k;
#endif
m.set(a, 1);
SASSERT(m.is_power_of_two(a, k) && k == 0);
ENSURE(m.is_power_of_two(a, k) && k == 0);
m.set(a, 2);
SASSERT(m.is_power_of_two(a, k) && k == 1);
ENSURE(m.is_power_of_two(a, k) && k == 1);
m.set(a, 3);
SASSERT(!m.is_power_of_two(a, k));
ENSURE(!m.is_power_of_two(a, k));
m.set(a, 4);
SASSERT(m.is_power_of_two(a, k) && k == 2);
ENSURE(m.is_power_of_two(a, k) && k == 2);
m.set(a, -4);
SASSERT(!m.is_power_of_two(a, k));
ENSURE(!m.is_power_of_two(a, k));
m.set(a, 8);
SASSERT(m.is_power_of_two(a, k) && k == 3);
ENSURE(m.is_power_of_two(a, k) && k == 3);
m.set(a, 0);
SASSERT(!m.is_power_of_two(a));
ENSURE(!m.is_power_of_two(a));
m.set(a, UINT_MAX);
m.inc(a);
SASSERT(m.is_power_of_two(a, k) && k == 32);
SASSERT(m.get_uint64(a) == static_cast<uint64>(UINT_MAX) + 1);
ENSURE(m.is_power_of_two(a, k) && k == 32);
ENSURE(m.get_uint64(a) == static_cast<uint64>(UINT_MAX) + 1);
m.power(a, 2, a);
SASSERT(m.is_power_of_two(a, k) && k == 64);
ENSURE(m.is_power_of_two(a, k) && k == 64);
m.power(a, 4, a);
SASSERT(m.is_power_of_two(a, k) && k == 256);
ENSURE(m.is_power_of_two(a, k) && k == 256);
m.round_to_plus_inf();
m.inc(a);
SASSERT(!m.is_power_of_two(a, k));
ENSURE(!m.is_power_of_two(a, k));
m.set(a, -4);
m.power(a, 3, a);
m.set(b, -64);
SASSERT(m.eq(a, b));
ENSURE(m.eq(a, b));
m.set(a, -4);
m.power(a, 4, a);
m.set(b, 256);
SASSERT(m.eq(a, b));
ENSURE(m.eq(a, b));
// additional tests
m.set(a, 5);
m.power(a, 3, a);
m.set(b, 5*5*5);
SASSERT(m.eq(a,b));
ENSURE(m.eq(a,b));
m.set(a, -5);
m.power(a, 3, a);
m.set(b, -5*5*5);
SASSERT(m.eq(a,b));
ENSURE(m.eq(a,b));
}
static void tst_sgn(unsigned prec) {
mpff_manager m(prec);
scoped_mpff a(m), b(m);
SASSERT(m.is_zero(a) && !m.is_pos(a) && !m.is_neg(a) && m.is_nonpos(a) && m.is_nonneg(a));
ENSURE(m.is_zero(a) && !m.is_pos(a) && !m.is_neg(a) && m.is_nonpos(a) && m.is_nonneg(a));
m.set(a, 3);
SASSERT(!m.is_zero(a) && m.is_pos(a) && !m.is_neg(a) && !m.is_nonpos(a) && m.is_nonneg(a));
ENSURE(!m.is_zero(a) && m.is_pos(a) && !m.is_neg(a) && !m.is_nonpos(a) && m.is_nonneg(a));
m.set(a, -3);
SASSERT(!m.is_zero(a) && !m.is_pos(a) && m.is_neg(a) && m.is_nonpos(a) && !m.is_nonneg(a));
ENSURE(!m.is_zero(a) && !m.is_pos(a) && m.is_neg(a) && m.is_nonpos(a) && !m.is_nonneg(a));
m.set(a, 8);
m.power(a, 256, a);
SASSERT(!m.is_zero(a) && m.is_pos(a) && !m.is_neg(a) && !m.is_nonpos(a) && m.is_nonneg(a));
ENSURE(!m.is_zero(a) && m.is_pos(a) && !m.is_neg(a) && !m.is_nonpos(a) && m.is_nonneg(a));
b = a;
m.neg(a);
SASSERT(m.neq(a, b));
SASSERT(!m.is_zero(a) && !m.is_pos(a) && m.is_neg(a) && m.is_nonpos(a) && !m.is_nonneg(a));
ENSURE(m.neq(a, b));
ENSURE(!m.is_zero(a) && !m.is_pos(a) && m.is_neg(a) && m.is_nonpos(a) && !m.is_nonneg(a));
m.neg(a);
SASSERT(m.eq(a, b));
ENSURE(m.eq(a, b));
m.set(a, 1);
SASSERT(m.is_one(a) && !m.is_zero(a) && !m.is_minus_one(a) && m.is_abs_one(a));
ENSURE(m.is_one(a) && !m.is_zero(a) && !m.is_minus_one(a) && m.is_abs_one(a));
m.neg(a);
SASSERT(!m.is_one(a) && !m.is_zero(a) && m.is_minus_one(a) && m.is_abs_one(a));
ENSURE(!m.is_one(a) && !m.is_zero(a) && m.is_minus_one(a) && m.is_abs_one(a));
m.set(a, 3);
SASSERT(!m.is_one(a) && !m.is_zero(a) && !m.is_minus_one(a));
ENSURE(!m.is_one(a) && !m.is_zero(a) && !m.is_minus_one(a));
m.set(a, 3);
b = a;
m.abs(a);
SASSERT(m.eq(a, b));
ENSURE(m.eq(a, b));
m.set(a, -3);
b = a;
m.abs(a);
SASSERT(!m.eq(a,b) && m.is_pos(a));
ENSURE(!m.eq(a,b) && m.is_pos(a));
m.set(a, 1);
m.swap(a, a);
SASSERT(m.is_one(a));
ENSURE(m.is_one(a));
m.set(b, -1);
m.swap(a, b);
SASSERT(m.is_one(b) && m.is_minus_one(a));
ENSURE(m.is_one(b) && m.is_minus_one(a));
m.neg(a);
SASSERT(m.eq(a, b));
ENSURE(m.eq(a, b));
}
static void tst_limits(unsigned prec) {
mpff_manager m(prec);
scoped_mpff a(m), b(m), two(m);
m.set_max(a);
SASSERT(m.is_pos(a));
ENSURE(m.is_pos(a));
m.set_min(b);
SASSERT(m.is_neg(b));
ENSURE(m.is_neg(b));
m.neg(a);
SASSERT(m.eq(a, b));
ENSURE(m.eq(a, b));
m.set_max(a);
m.set_max(b);
m.round_to_minus_inf();
m.inc(a);
SASSERT(m.eq(a, b));
ENSURE(m.eq(a, b));
m.dec(a);
SASSERT(m.lt(a, b));
ENSURE(m.lt(a, b));
m.set_max(a);
m.round_to_plus_inf();
bool overflow = false;
@ -438,99 +438,99 @@ static void tst_limits(unsigned prec) {
VERIFY(overflow);
m.set_max(a);
m.dec(a);
SASSERT(m.eq(a, b));
ENSURE(m.eq(a, b));
m.set_min(a);
m.set_min(b);
m.round_to_minus_inf();
m.inc(a);
SASSERT(m.eq(a, b));
ENSURE(m.eq(a, b));
overflow = true;
try { m.dec(a); }
catch (mpff_manager::overflow_exception) { overflow = true; }
SASSERT(overflow);
ENSURE(overflow);
m.round_to_plus_inf();
m.set_min(a);
m.inc(a);
SASSERT(m.gt(a,b));
ENSURE(m.gt(a,b));
m.set_min(a);
m.dec(a);
SASSERT(m.eq(a,b));
ENSURE(m.eq(a,b));
m.set_plus_epsilon(a);
m.set_plus_epsilon(b);
SASSERT(!m.is_zero(a) && m.is_pos(a));
ENSURE(!m.is_zero(a) && m.is_pos(a));
m.set(two, 2);
m.round_to_plus_inf();
m.div(a, two, a);
SASSERT(m.eq(a, b));
ENSURE(m.eq(a, b));
m.round_to_minus_inf();
m.div(a, two, a);
SASSERT(m.is_zero(a));
ENSURE(m.is_zero(a));
m.round_to_plus_inf();
m.set_plus_epsilon(a);
m.add(a, a, a);
SASSERT(m.gt(a, b));
ENSURE(m.gt(a, b));
m.round_to_minus_inf();
m.set_plus_epsilon(a);
m.add(a, a, a);
SASSERT(m.gt(a, b));
ENSURE(m.gt(a, b));
m.set_plus_epsilon(a);
m.sub(a, a, a);
SASSERT(m.is_zero(a));
ENSURE(m.is_zero(a));
m.set_plus_epsilon(a);
SASSERT(m.is_plus_epsilon(a));
SASSERT(!m.is_minus_epsilon(a));
ENSURE(m.is_plus_epsilon(a));
ENSURE(!m.is_minus_epsilon(a));
m.neg(a);
SASSERT(!m.is_plus_epsilon(a));
SASSERT(m.is_minus_epsilon(a));
ENSURE(!m.is_plus_epsilon(a));
ENSURE(m.is_minus_epsilon(a));
for (unsigned i = 0; i < 2; i++) {
m.set_rounding(i == 0);
m.set_plus_epsilon(a);
m.floor(a);
SASSERT(m.is_zero(a));
ENSURE(m.is_zero(a));
m.set_plus_epsilon(a);
m.ceil(a);
SASSERT(m.is_one(a));
ENSURE(m.is_one(a));
m.set_minus_epsilon(a);
m.floor(a);
SASSERT(m.is_minus_one(a));
ENSURE(m.is_minus_one(a));
m.set_minus_epsilon(a);
m.ceil(a);
SASSERT(m.is_zero(a));
ENSURE(m.is_zero(a));
}
m.set_minus_epsilon(a);
m.set_minus_epsilon(b);
SASSERT(!m.is_zero(a) && m.is_neg(a));
ENSURE(!m.is_zero(a) && m.is_neg(a));
m.set(two, 2);
m.round_to_minus_inf();
m.div(a, two, a);
SASSERT(m.eq(a, b));
ENSURE(m.eq(a, b));
m.round_to_plus_inf();
m.div(a, two, a);
SASSERT(m.is_zero(a));
ENSURE(m.is_zero(a));
m.round_to_plus_inf();
m.set_minus_epsilon(a);
m.add(a, a, a);
SASSERT(m.lt(a, b));
ENSURE(m.lt(a, b));
m.round_to_minus_inf();
m.set_minus_epsilon(a);
m.add(a, a, a);
SASSERT(m.lt(a, b));
ENSURE(m.lt(a, b));
m.set_minus_epsilon(a);
m.sub(a, a, a);
SASSERT(m.is_zero(a));
ENSURE(m.is_zero(a));
m.set_minus_epsilon(a);
SASSERT(!m.is_plus_epsilon(a));
SASSERT(m.is_minus_epsilon(a));
ENSURE(!m.is_plus_epsilon(a));
ENSURE(m.is_minus_epsilon(a));
m.neg(a);
SASSERT(m.is_plus_epsilon(a));
SASSERT(!m.is_minus_epsilon(a));
ENSURE(m.is_plus_epsilon(a));
ENSURE(!m.is_minus_epsilon(a));
}
#if 0
@ -549,7 +549,7 @@ static void tst_decimal(int64 n, uint64 d, bool to_plus_inf, unsigned prec, char
m.display_decimal(std::cout, a, decimal_places); std::cout << std::endl;
std::ostringstream buffer;
m.display_decimal(buffer, a, decimal_places);
SASSERT(strcmp(expected, buffer.str().c_str()) == 0);
ENSURE(strcmp(expected, buffer.str().c_str()) == 0);
}
static void tst_decimal() {
@ -573,7 +573,7 @@ static void tst_prev_power_2(int64 n, uint64 d, unsigned expected) {
mpff_manager m;
scoped_mpff a(m);
m.set(a, n, d);
SASSERT(m.prev_power_of_two(a) == expected);
ENSURE(m.prev_power_of_two(a) == expected);
}
static void tst_prev_power_2() {