mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-05-06 15:25:46 +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

326
src/test/rational.cpp
View file

@ -27,85 +27,85 @@ static void tst1() {
rational r1(1);
rational r2(1,2);
rational r3(2,4);
SASSERT(r2 == r3);
SASSERT(r1 != r2);
SASSERT(r2 + r3 == r1);
SASSERT(r1.is_pos());
SASSERT((r2 - r1).is_neg());
SASSERT((r2 - r3).is_zero());
SASSERT(floor(r2).is_zero());
SASSERT(ceil(r2).is_one());
ENSURE(r2 == r3);
ENSURE(r1 != r2);
ENSURE(r2 + r3 == r1);
ENSURE(r1.is_pos());
ENSURE((r2 - r1).is_neg());
ENSURE((r2 - r3).is_zero());
ENSURE(floor(r2).is_zero());
ENSURE(ceil(r2).is_one());
// std::cout << "-r2: " << (-r2) << ", floor(-r2):" << floor(-r2) << "\n";
SASSERT(floor(-r2).is_minus_one());
SASSERT(ceil(-r2).is_zero());
SASSERT(floor(r1) == r1);
SASSERT(ceil(r1) == r1);
ENSURE(floor(-r2).is_minus_one());
ENSURE(ceil(-r2).is_zero());
ENSURE(floor(r1) == r1);
ENSURE(ceil(r1) == r1);
rational r4(3,5);
SASSERT(r3 * r4 == rational(3, 10));
SASSERT(r3 / r4 == rational(5, 6));
ENSURE(r3 * r4 == rational(3, 10));
ENSURE(r3 / r4 == rational(5, 6));
rational r5(2,3);
SASSERT(r4 * r5 == rational(2, 5));
ENSURE(r4 * r5 == rational(2, 5));
--r2;
SASSERT(r2 == -r3);
ENSURE(r2 == -r3);
r2.neg();
SASSERT(r2 == r3);
ENSURE(r2 == r3);
--r2;
r2 = abs(r2);
SASSERT(r2 == r3);
ENSURE(r2 == r3);
--r2;
++r2;
SASSERT(r2 == r3);
SASSERT(r2 == abs(r2));
SASSERT(r4 * rational(1) == r4);
SASSERT((r4 * rational(0)).is_zero());
SASSERT(r4 * rational(-1) == -r4);
SASSERT(rational(1) * r4 == r4);
SASSERT((rational(0) * r4).is_zero());
SASSERT(rational(-1) * r4 == -r4);
SASSERT(r4 + rational(0) == r4);
SASSERT(ceil(r4).is_one());
ENSURE(r2 == r3);
ENSURE(r2 == abs(r2));
ENSURE(r4 * rational(1) == r4);
ENSURE((r4 * rational(0)).is_zero());
ENSURE(r4 * rational(-1) == -r4);
ENSURE(rational(1) * r4 == r4);
ENSURE((rational(0) * r4).is_zero());
ENSURE(rational(-1) * r4 == -r4);
ENSURE(r4 + rational(0) == r4);
ENSURE(ceil(r4).is_one());
// std::cout << "r3: " << r3 << ", r4: " << r4 << ", -r4: " << -r4 << ", r3 / (-r4): " << (r3 / (-r4)) << "\n";
SASSERT(r3 / (-r4) == rational(5,-6));
SASSERT(div(rational(7), rational(2)) == rational(3));
SASSERT(rational(7) % rational(4) == rational(3));
SASSERT(div(rational(7), rational(-2)) == rational(-3));
SASSERT(rational(3) + rational(5) == rational(8));
SASSERT(rational("13/10") + rational("7/10") == rational(2));
SASSERT(rational("100/20") == rational(5));
SASSERT(gcd(rational(12), rational(8)) == rational(4));
SASSERT(ceil(rational(-3,2)) == rational(-1));
SASSERT(floor(rational(-3,2)) == rational(-2));
SASSERT(ceil(rational(3,2)) == rational(2));
SASSERT(floor(rational(3,2)) == rational(1));
SASSERT(rational(3).is_pos());
SASSERT(rational(0).is_nonneg());
SASSERT(rational(3).is_pos());
SASSERT(rational(3).is_nonneg());
SASSERT(rational(0).is_nonneg());
SASSERT(!rational(3).is_zero());
SASSERT(!rational(-3).is_zero());
SASSERT(rational(0).is_zero());
SASSERT(rational(1).is_one());
SASSERT(!rational(2).is_one());
SASSERT(rational(3,4) >= rational(2,8));
SASSERT(rational(3,4) <= rational(7,8));
SASSERT(rational(3,4) <= rational(3,4));
SASSERT(rational(3,4) >= rational(3,4));
SASSERT(rational(3,4) > rational(2,8));
SASSERT(rational(3,4) < rational(7,8));
ENSURE(r3 / (-r4) == rational(5,-6));
ENSURE(div(rational(7), rational(2)) == rational(3));
ENSURE(rational(7) % rational(4) == rational(3));
ENSURE(div(rational(7), rational(-2)) == rational(-3));
ENSURE(rational(3) + rational(5) == rational(8));
ENSURE(rational("13/10") + rational("7/10") == rational(2));
ENSURE(rational("100/20") == rational(5));
ENSURE(gcd(rational(12), rational(8)) == rational(4));
ENSURE(ceil(rational(-3,2)) == rational(-1));
ENSURE(floor(rational(-3,2)) == rational(-2));
ENSURE(ceil(rational(3,2)) == rational(2));
ENSURE(floor(rational(3,2)) == rational(1));
ENSURE(rational(3).is_pos());
ENSURE(rational(0).is_nonneg());
ENSURE(rational(3).is_pos());
ENSURE(rational(3).is_nonneg());
ENSURE(rational(0).is_nonneg());
ENSURE(!rational(3).is_zero());
ENSURE(!rational(-3).is_zero());
ENSURE(rational(0).is_zero());
ENSURE(rational(1).is_one());
ENSURE(!rational(2).is_one());
ENSURE(rational(3,4) >= rational(2,8));
ENSURE(rational(3,4) <= rational(7,8));
ENSURE(rational(3,4) <= rational(3,4));
ENSURE(rational(3,4) >= rational(3,4));
ENSURE(rational(3,4) > rational(2,8));
ENSURE(rational(3,4) < rational(7,8));
TRACE("rational", tout << rational(3,4) << "\n";);
TRACE("rational", tout << rational(7,9) << "\n";);
TRACE("rational", tout << rational(-3,7) << "\n";);
TRACE("rational", tout << rational(5,8) << "\n";);
TRACE("rational", tout << rational(4,2) << "\n";);
SASSERT(rational(3) + rational(2) == rational(5));
SASSERT(rational(3) - rational(2) == rational(1));
SASSERT(rational(3) * rational(2) == rational(6));
SASSERT(rational(6) / rational(2) == rational(3));
SASSERT(rational(6) % rational(4) == rational(2));
SASSERT(power(rational(2),0) == rational(1));
SASSERT(power(rational(2),1) == rational(2));
SASSERT(power(rational(2),3) == rational(8));
ENSURE(rational(3) + rational(2) == rational(5));
ENSURE(rational(3) - rational(2) == rational(1));
ENSURE(rational(3) * rational(2) == rational(6));
ENSURE(rational(6) / rational(2) == rational(3));
ENSURE(rational(6) % rational(4) == rational(2));
ENSURE(power(rational(2),0) == rational(1));
ENSURE(power(rational(2),1) == rational(2));
ENSURE(power(rational(2),3) == rational(8));
}
static void tst2() {
@ -116,90 +116,90 @@ static void tst2() {
TRACE("rational", tout << r2 << std::endl;);
TRACE("rational", tout << r3 << std::endl;);
SASSERT(r2 == r3);
SASSERT(r1 != r2);
SASSERT(rational(2)*r2 + r3 == r1);
SASSERT(r1.is_pos());
SASSERT((r2 - r1).is_neg());
SASSERT((r2 - r3).is_zero());
ENSURE(r2 == r3);
ENSURE(r1 != r2);
ENSURE(rational(2)*r2 + r3 == r1);
ENSURE(r1.is_pos());
ENSURE((r2 - r1).is_neg());
ENSURE((r2 - r3).is_zero());
// std::cout << "===> " << floor(r2) << "\n";
{
rational r0("1/3000000000000000000000000");
SASSERT(ceil(r0).is_one());
SASSERT(floor(-r0).is_minus_one());
SASSERT(ceil(-r0).is_zero());
ENSURE(ceil(r0).is_one());
ENSURE(floor(-r0).is_minus_one());
ENSURE(ceil(-r0).is_zero());
}
SASSERT(floor(r1) == r1);
SASSERT(ceil(r1) == r1);
ENSURE(floor(r1) == r1);
ENSURE(ceil(r1) == r1);
rational r4("300000000/5");
SASSERT(rational(1,2) * r4 == rational("300000000/10"));
SASSERT(rational(1,2) / r4 == rational("5/600000000"));
ENSURE(rational(1,2) * r4 == rational("300000000/10"));
ENSURE(rational(1,2) / r4 == rational("5/600000000"));
rational r5(2,3);
SASSERT(r4 * r5 == rational("200000000/5"));
ENSURE(r4 * r5 == rational("200000000/5"));
rational r6("10000000000000000000000000000000003/3");
--r6;
SASSERT(r6 == r2);
ENSURE(r6 == r2);
r6.neg();
SASSERT(r6 != r2);
SASSERT(abs(r6) == r2);
ENSURE(r6 != r2);
ENSURE(abs(r6) == r2);
--r2;
++r2;
r2.neg();
SASSERT(r2 == r6);
SASSERT(r6 * rational(1) == r6);
SASSERT((r6 * rational(0)).is_zero());
SASSERT(r6 * rational(-1) == -r6);
SASSERT(rational(1) * r6 == r6);
SASSERT((rational(0) * r6).is_zero());
SASSERT(rational(-1) * r6 == -r6);
SASSERT(r6 + rational(0) == r6);
ENSURE(r2 == r6);
ENSURE(r6 * rational(1) == r6);
ENSURE((r6 * rational(0)).is_zero());
ENSURE(r6 * rational(-1) == -r6);
ENSURE(rational(1) * r6 == r6);
ENSURE((rational(0) * r6).is_zero());
ENSURE(rational(-1) * r6 == -r6);
ENSURE(r6 + rational(0) == r6);
SASSERT(rational("300000000000000").is_pos());
SASSERT(rational("0000000000000000000").is_nonneg());
SASSERT(rational("0000000000000000000").is_nonpos());
SASSERT(rational("3000000000000000000/2").is_pos());
SASSERT(rational("3000000000000000000/2").is_nonneg());
SASSERT((-rational("3000000000000000000/2")).is_neg());
SASSERT(!rational("3000000000000000000/2").is_neg());
SASSERT(!rational("3000000000000000000/2").is_zero());
SASSERT(!rational("3000000000000000000/2").is_one());
SASSERT(rational("99999999999/2") >= rational("23/2"));
SASSERT(rational("99999999999/2") > rational("23/2"));
SASSERT(rational("23/2") <= rational("99999999999/2"));
SASSERT(rational("23/2") < rational("99999999999/2"));
SASSERT(!(rational("99999999999/2") < rational("23/2")));
ENSURE(rational("300000000000000").is_pos());
ENSURE(rational("0000000000000000000").is_nonneg());
ENSURE(rational("0000000000000000000").is_nonpos());
ENSURE(rational("3000000000000000000/2").is_pos());
ENSURE(rational("3000000000000000000/2").is_nonneg());
ENSURE((-rational("3000000000000000000/2")).is_neg());
ENSURE(!rational("3000000000000000000/2").is_neg());
ENSURE(!rational("3000000000000000000/2").is_zero());
ENSURE(!rational("3000000000000000000/2").is_one());
ENSURE(rational("99999999999/2") >= rational("23/2"));
ENSURE(rational("99999999999/2") > rational("23/2"));
ENSURE(rational("23/2") <= rational("99999999999/2"));
ENSURE(rational("23/2") < rational("99999999999/2"));
ENSURE(!(rational("99999999999/2") < rational("23/2")));
rational int64_max("9223372036854775807");
rational int64_min((-int64_max) - rational(1));
// is_int64
SASSERT(int64_max.is_int64());
SASSERT(int64_min.is_int64());
SASSERT(rational(0).is_int64());
SASSERT(rational(1).is_int64());
SASSERT(rational(-1).is_int64());
SASSERT(!(int64_max + rational(1)).is_int64());
SASSERT(!(int64_min - rational(1)).is_int64());
ENSURE(int64_max.is_int64());
ENSURE(int64_min.is_int64());
ENSURE(rational(0).is_int64());
ENSURE(rational(1).is_int64());
ENSURE(rational(-1).is_int64());
ENSURE(!(int64_max + rational(1)).is_int64());
ENSURE(!(int64_min - rational(1)).is_int64());
// is_uint64
SASSERT(int64_max.is_uint64());
SASSERT(!int64_min.is_uint64());
SASSERT(rational(0).is_uint64());
SASSERT(rational(1).is_uint64());
SASSERT(!rational(-1).is_uint64());
SASSERT((int64_max + rational(1)).is_uint64());
SASSERT(!(int64_min - rational(1)).is_uint64());
ENSURE(int64_max.is_uint64());
ENSURE(!int64_min.is_uint64());
ENSURE(rational(0).is_uint64());
ENSURE(rational(1).is_uint64());
ENSURE(!rational(-1).is_uint64());
ENSURE((int64_max + rational(1)).is_uint64());
ENSURE(!(int64_min - rational(1)).is_uint64());
rational uint64_max(rational(1) + (rational(2) * int64_max));
SASSERT(uint64_max.is_uint64());
ENSURE(uint64_max.is_uint64());
// get_int64, get_uint64
uint64 u1 = uint64_max.get_uint64();
uint64 u2 = UINT64_MAX;
VERIFY(u1 == u2);
std::cout << "int64_max: " << int64_max << ", INT64_MAX: " << INT64_MAX << ", int64_max.get_int64(): " << int64_max.get_int64() << ", int64_max.get_uint64(): " << int64_max.get_uint64() << "\n";
SASSERT(int64_max.get_int64() == INT64_MAX);
SASSERT(int64_min.get_int64() == INT64_MIN);
ENSURE(int64_max.get_int64() == INT64_MAX);
ENSURE(int64_min.get_int64() == INT64_MIN);
// extended Euclid:
@ -219,7 +219,7 @@ void tst3() {
TRACE("rational",
tout << "n4: " << n4 << "\n";
tout << "n5: " << n5 << "\n";);
SASSERT(n5 == rational("2147483646"));
ENSURE(n5 == rational("2147483646"));
}
void tst4() {
@ -236,7 +236,7 @@ void tst5() {
TRACE("rational", tout << n1 << " " << n2 << " " << n1.is_big() << " " << n2.is_big() << "\n";);
n1 *= n2;
TRACE("rational", tout << "after: " << n1 << " " << n2 << "\n";);
SASSERT(n1.is_minus_one());
ENSURE(n1.is_minus_one());
}
void tst6() {
@ -274,8 +274,8 @@ public:
static void tst1() {
rational n1(-1);
rational n2(8);
SASSERT((n1 % n2).is_minus_one());
SASSERT(mod(n1, n2) == rational(7));
ENSURE((n1 % n2).is_minus_one());
ENSURE(mod(n1, n2) == rational(7));
}
static void tst_hash(int val) {
@ -283,7 +283,7 @@ public:
rational n2("10203939394995449949494394932929");
rational n3(val);
n2 = n3;
SASSERT(n1.hash() == n2.hash());
ENSURE(n1.hash() == n2.hash());
}
static void tst2() {
@ -306,47 +306,47 @@ static void tst7() {
rational gcd;
extended_gcd(n, p, gcd, x, y);
TRACE("gcd", tout << n << " " << p << ": " << gcd << " " << x << " " << y << "\n";);
SASSERT(!mod(n, rational(2)).is_one() || mod(n * x, p).is_one());
ENSURE(!mod(n, rational(2)).is_one() || mod(n * x, p).is_one());
}
}
static void tst8() {
rational r;
SASSERT(!rational(-4).is_int_perfect_square(r) && r.is_zero());
SASSERT(!rational(-3).is_int_perfect_square(r) && r.is_zero());
SASSERT(!rational(-2).is_int_perfect_square(r) && r.is_zero());
SASSERT(!rational(-1).is_int_perfect_square(r) && r.is_zero());
SASSERT(rational(0).is_int_perfect_square(r) && r.is_zero());
SASSERT(rational(1).is_int_perfect_square(r) && r.is_one());
SASSERT(!rational(2).is_int_perfect_square(r) && r == rational(2));
SASSERT(!rational(3).is_int_perfect_square(r) && r == rational(2));
SASSERT(rational(4).is_int_perfect_square(r) && r == rational(2));
SASSERT(!rational(5).is_int_perfect_square(r) && r == rational(3));
SASSERT(!rational(6).is_int_perfect_square(r) && r == rational(3));
SASSERT(!rational(7).is_int_perfect_square(r) && r == rational(3));
SASSERT(!rational(8).is_int_perfect_square(r) && r == rational(3));
SASSERT(rational(9).is_int_perfect_square(r) && r == rational(3));
SASSERT(!rational(10).is_int_perfect_square(r) && r == rational(4));
SASSERT(!rational(11).is_int_perfect_square(r) && r == rational(4));
SASSERT(!rational(12).is_int_perfect_square(r) && r == rational(4));
SASSERT(!rational(13).is_int_perfect_square(r) && r == rational(4));
SASSERT(!rational(14).is_int_perfect_square(r) && r == rational(4));
SASSERT(!rational(15).is_int_perfect_square(r) && r == rational(4));
SASSERT(rational(16).is_int_perfect_square(r) && r == rational(4));
SASSERT(!rational(17).is_int_perfect_square(r) && r == rational(5));
SASSERT(!rational(18).is_int_perfect_square(r) && r == rational(5));
SASSERT(!rational(19).is_int_perfect_square(r) && r == rational(5));
SASSERT(!rational(20).is_int_perfect_square(r) && r == rational(5));
SASSERT(!rational(21).is_int_perfect_square(r) && r == rational(5));
SASSERT(!rational(22).is_int_perfect_square(r) && r == rational(5));
SASSERT(!rational(23).is_int_perfect_square(r) && r == rational(5));
SASSERT(!rational(24).is_int_perfect_square(r) && r == rational(5));
SASSERT(rational(25).is_int_perfect_square(r) && r == rational(5));
SASSERT(!rational(26).is_int_perfect_square(r) && r == rational(6));
SASSERT(rational(36).is_int_perfect_square(r) && r == rational(6));
ENSURE(!rational(-4).is_int_perfect_square(r) && r.is_zero());
ENSURE(!rational(-3).is_int_perfect_square(r) && r.is_zero());
ENSURE(!rational(-2).is_int_perfect_square(r) && r.is_zero());
ENSURE(!rational(-1).is_int_perfect_square(r) && r.is_zero());
ENSURE(rational(0).is_int_perfect_square(r) && r.is_zero());
ENSURE(rational(1).is_int_perfect_square(r) && r.is_one());
ENSURE(!rational(2).is_int_perfect_square(r) && r == rational(2));
ENSURE(!rational(3).is_int_perfect_square(r) && r == rational(2));
ENSURE(rational(4).is_int_perfect_square(r) && r == rational(2));
ENSURE(!rational(5).is_int_perfect_square(r) && r == rational(3));
ENSURE(!rational(6).is_int_perfect_square(r) && r == rational(3));
ENSURE(!rational(7).is_int_perfect_square(r) && r == rational(3));
ENSURE(!rational(8).is_int_perfect_square(r) && r == rational(3));
ENSURE(rational(9).is_int_perfect_square(r) && r == rational(3));
ENSURE(!rational(10).is_int_perfect_square(r) && r == rational(4));
ENSURE(!rational(11).is_int_perfect_square(r) && r == rational(4));
ENSURE(!rational(12).is_int_perfect_square(r) && r == rational(4));
ENSURE(!rational(13).is_int_perfect_square(r) && r == rational(4));
ENSURE(!rational(14).is_int_perfect_square(r) && r == rational(4));
ENSURE(!rational(15).is_int_perfect_square(r) && r == rational(4));
ENSURE(rational(16).is_int_perfect_square(r) && r == rational(4));
ENSURE(!rational(17).is_int_perfect_square(r) && r == rational(5));
ENSURE(!rational(18).is_int_perfect_square(r) && r == rational(5));
ENSURE(!rational(19).is_int_perfect_square(r) && r == rational(5));
ENSURE(!rational(20).is_int_perfect_square(r) && r == rational(5));
ENSURE(!rational(21).is_int_perfect_square(r) && r == rational(5));
ENSURE(!rational(22).is_int_perfect_square(r) && r == rational(5));
ENSURE(!rational(23).is_int_perfect_square(r) && r == rational(5));
ENSURE(!rational(24).is_int_perfect_square(r) && r == rational(5));
ENSURE(rational(25).is_int_perfect_square(r) && r == rational(5));
ENSURE(!rational(26).is_int_perfect_square(r) && r == rational(6));
ENSURE(rational(36).is_int_perfect_square(r) && r == rational(6));
SASSERT(rational(1,9).is_perfect_square(r) && r == rational(1,3));
SASSERT(rational(4,9).is_perfect_square(r) && r == rational(2,3));
ENSURE(rational(1,9).is_perfect_square(r) && r == rational(1,3));
ENSURE(rational(4,9).is_perfect_square(r) && r == rational(2,3));
}
@ -363,9 +363,9 @@ static void tstmod(rational const& m, rational const& n) {
std::cout << m << " " << n << " " << q << " " << r << "\n";
std::cout << m << " == " << n*q+r << "\n";
SASSERT(m == (n * q) + r);
SASSERT(rational::zero() <= r);
SASSERT(r < abs(n));
ENSURE(m == (n * q) + r);
ENSURE(rational::zero() <= r);
ENSURE(r < abs(n));
}