mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-23 17:15:31 +00:00
Code Activity

reorganization of rule_set structure

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2013-04-08 13:50:56 -07:00
parent 5915533170
commit 8f46179def
65 changed files with 778 additions and 10668 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/test/dl_query.cpp
View file

@ -59,7 +59,7 @@ void dl_query_test(ast_manager & m, smt_params & fparams, params_ref& params,
}
relation_manager & rel_mgr_q = ctx_b.get_rel_context().get_rmanager();
decl_set out_preds = ctx_b.get_output_predicates();
decl_set out_preds = ctx_b.get_rules().get_output_predicates();
decl_set::iterator it = out_preds.begin();
decl_set::iterator end = out_preds.end();
for(; it!=end; ++it) {

12
src/test/dl_table.cpp
View file

@ -1,7 +1,6 @@
#ifdef _WINDOWS
#include "dl_context.h"
#include "dl_table.h"
#include "dl_skip_table.h"
typedef datalog::table_base* (*mk_table_fn)(datalog::relation_manager& m, datalog::table_signature& sig);
@ -11,13 +10,6 @@ static datalog::table_base* mk_bv_table(datalog::relation_manager& m, datalog::t
return p->mk_empty(sig);
}
static datalog::table_base* mk_skip_table(datalog::relation_manager& m, datalog::table_signature& sig) {
datalog::table_plugin * p = m.get_table_plugin(symbol("skip"));
SASSERT(p);
return p->mk_empty(sig);
}
static void test_table(mk_table_fn mk_table) {
datalog::table_signature sig;
sig.push_back(2);
@ -96,13 +88,9 @@ void test_dl_bitvector_table() {
test_table(mk_bv_table);
}
void test_dl_skip_table() {
test_table(mk_skip_table);
}
void tst_dl_table() {
test_dl_bitvector_table();
test_dl_skip_table();
}
#else
void tst_dl_table() {

617
src/test/imdd.cpp
View file

@ -1,617 +0,0 @@
/*++
Copyright (c) 2006 Microsoft Corporation
Module Name:
imdd.cpp
Abstract:
<abstract>
Author:
Leonardo de Moura (leonardo) 2010-10-14.
Revision History:
--*/
#include"imdd.h"
#if !defined(_AMD64_) && defined(Z3DEBUG)
static void tst0() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d1(m), d2(m), d3(m), d4(m);
d1 = m.mk_empty(1);
d2 = m.mk_empty(1);
m.insert_dupdt(d1, 10, 20);
m.insert_dupdt(d1, 31, 50);
m.insert_dupdt(d2, 1, 5);
m.insert_dupdt(d2, 11, 13);
m.mk_product(d1, d2, d4);
m.mk_product(d4, d2, d4);
m.mk_product_dupdt(d1, d2);
std::cout << "d1:\n" << mk_ll_pp(d1, m) << "\n-------\n";
m.mk_product_dupdt(d1, d2);
std::cout << "d4:\n" << mk_ll_pp(d4, m) << "\nd1:\n" << mk_ll_pp(d1, m) << "\nd2:\n" << mk_ll_pp(d2, m) << "\n";
std::cout << d1 << "\n" << d2 << "\n";
m.mk_product_dupdt(d1, d1);
std::cout << "d1 X d1:\n" << mk_ll_pp(d1, m) << "\n";
}
static void add_triple(imdd_manager & m, imdd_ref & d, unsigned l1, unsigned u1, unsigned l2, unsigned u2, unsigned l3, unsigned u3,
bool destructive = false, bool memoize = true) {
unsigned lowers[3] = {l1, l2, l3};
unsigned uppers[3] = {u1, u2, u3};
if (destructive)
m.add_facts_dupdt(d, 3, lowers, uppers, memoize);
else
m.add_facts(d, d, 3, lowers, uppers, memoize);
// std::cout << mk_ll_pp(d, m) << "\n";
}
static void add_pair(imdd_manager & m, imdd_ref & d, unsigned l1, unsigned u1, unsigned l2, unsigned u2, bool destructive = false, bool memoize = true) {
unsigned lowers[2] = {l1, l2};
unsigned uppers[2] = {u1, u2};
if (destructive)
m.add_facts_dupdt(d, 2, lowers, uppers, memoize);
else
m.add_facts(d, d, 2, lowers, uppers, memoize);
// std::cout << mk_ll_pp(d, m) << "\n";
}
static void add_some_facts(imdd_manager & m, imdd_ref & d, bool destructive = false, bool memoize = true) {
std::cout << "destructive: " << destructive << ", memoize: " << memoize << std::endl;
add_triple(m, d, 1, 10, 3, 3, 0, 100, destructive, memoize);
std::cout << mk_ll_pp(d, m) << std::endl;
SASSERT(m.contains(d, 2, 3, 20));
SASSERT(!m.contains(d, 2, 4, 20));
SASSERT(!m.contains(d, 2, 3, 200));
SASSERT(!m.contains(d, 0, 3, 200));
SASSERT(m.contains(d,1,3,0));
add_triple(m, d, 3, 6, 3, 4, 7, 101, destructive, memoize);
std::cout << mk_ll_pp(d, m) << std::endl;
add_triple(m, d, 3, 6, 2, 2, 7, 101, destructive, memoize);
std::cout << mk_ll_pp(d, m) << std::endl;
add_triple(m, d, 3, 6, 5, 6, 7, 101, destructive, memoize);
SASSERT(m.contains(d, 2, 3, 20));
std::cout << mk_ll_pp(d, m) << std::endl;
SASSERT(!m.contains(d, 2, 4, 20));
SASSERT(m.contains(d, 3, 4, 20));
SASSERT(!m.contains(d, 2, 3, 200));
SASSERT(!m.contains(d, 0, 3, 200));
SASSERT(m.contains(d,1,3,0));
}
static void tst1() {
std::cout << "--------------------------------\n";
imdd_manager m;
{
imdd_ref d(m);
d = m.mk_empty(3);
add_some_facts(m, d);
}
{
imdd_ref d(m);
d = m.mk_empty(3);
add_some_facts(m, d, true, false);
m.defrag(d);
std::cout << mk_ll_pp(d, m) << "\n";
}
}
static void tst2() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d1(m), d2(m), d3(m);
d1 = m.mk_empty(3);
add_triple(m, d1, 10, 20, 11, 21, 12, 22);
add_triple(m, d1, 30, 40, 31, 41, 32, 42);
d2 = m.mk_empty(3);
add_triple(m, d2, 15, 22, 15, 23, 7, 18);
add_triple(m, d2, 28, 42, 29, 39, 34, 46);
add_triple(m, d2, 28, 42, 29, 39, 100, 200);
add_triple(m, d2, 28, 42, 50, 60, 100, 200);
std::cout << mk_ll_pp(d1, m) << "\n";
std::cout << mk_ll_pp(d2, m) << "\n";
m.mk_union(d1, d2, d3);
SASSERT(m.subsumes(d3, d1));
SASSERT(m.subsumes(d3, d2));
SASSERT(!m.subsumes(d1, d3));
SASSERT(!m.subsumes(d2, d3));
std::cout << "d3: " << d3.get() << "\n" << mk_ll_pp(d3, m) << "\n";
m.mk_union_dupdt(d1, d2, false);
std::cout << "d1: " << d1.get() << "\n" << mk_ll_pp(d1, m) << "\n";
SASSERT(m.is_equal(d1, d3));
SASSERT(!m.is_equal(d2, d3));
SASSERT(!m.is_equal(d2, d1));
std::cout << "memory(d1): " << m.memory(d1) << "\n";
}
static void tst3() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d1(m);
d1 = m.mk_empty(3);
unsigned mins[3] = {0,0,0};
unsigned maxs[3] = {127, 511, 255};
m.mk_complement(d1, d1, 3, mins, maxs);
std::cout << d1 << "\n";
m.mk_complement(d1, d1, 3, mins, maxs);
std::cout << d1 << "\n";
SASSERT(d1->empty());
d1 = m.mk_empty(3);
add_triple(m, d1, 10, 20, 11, 21, 12, 22);
add_triple(m, d1, 30, 40, 31, 41, 32, 42);
std::cout << d1 << "\n";
m.mk_complement(d1, d1, 3, mins, maxs);
std::cout << mk_ll_pp(d1,m) << "\n";
m.mk_filter_equal(d1, d1, 1, 15);
std::cout << "after selecting second column = 15\n" << mk_ll_pp(d1,m) << "\n";
}
static void tst4() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d1(m);
d1 = m.mk_empty(3);
add_triple(m, d1, 1, 2, 2, 5, 4, 4);
add_triple(m, d1, 3, 4, 3, 4, 2, 5);
std::cout << "testing iterator:\n";
imdd_manager::iterator it = m.begin(d1);
imdd_manager::iterator end = m.end(d1);
for (; it != end; ++it) {
unsigned * tuple = *it;
std::cout << "[";
for (unsigned i = 0; i < d1->get_arity(); i++) {
if (i > 0)
std::cout << ", ";
std::cout << tuple[i];
}
std::cout << "]\n";
}
}
static void tst5() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d1(m), d2(m), d3(m);
std::cout.flush();
d1 = m.mk_empty(3);
add_triple(m, d1, 5, 100, 10, 20, 3, 10);
std::cout << mk_ll_pp(d1,m) << std::endl;
add_triple(m, d1, 5, 100, 34, 50, 98, 110);
std::cout << mk_ll_pp(d1,m) << std::endl;
unsigned vals[3] = {6, 8, 3};
SASSERT(!m.contains(d1, 3, vals));
add_triple(m, d1, 6, 25, 8, 30, 14, 50);
std::cout << mk_ll_pp(d1,m) << std::endl;
SASSERT(!m.contains(d1, 3, vals));
unsigned vars[2] = {0, 2};
d2 = d1;
d3 = d1;
m.mk_filter_identical(d1, d1, 2, vars);
vars[1] = 1;
std::cout << "d1:\n" << mk_ll_pp(d1,m) << "\n";
m.mk_filter_identical(d2, d2, 2, vars);
std::cout << "d2:\n" << mk_ll_pp(d2,m) << "\n";
vars[0] = 1;
vars[1] = 2;
m.mk_filter_identical(d3, d3, 2, vars);
std::cout << "d3:\n" << mk_ll_pp(d3,m) << "\n";
}
static void add_5tuple(imdd_manager & m, imdd_ref & d, unsigned l1, unsigned u1, unsigned l2, unsigned u2, unsigned l3, unsigned u3,
unsigned l4, unsigned u4, unsigned l5, unsigned u5, bool destructive = false, bool memoize = true) {
unsigned lowers[5] = {l1, l2, l3, l4, l5};
unsigned uppers[5] = {u1, u2, u3, u4, u5};
if (destructive)
m.add_facts_dupdt(d, 5, lowers, uppers, memoize);
else
m.add_facts(d, d, 5, lowers, uppers, memoize);
// std::cout << mk_ll_pp(d, m) << "\n";
}
static void tst6() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d1(m);
std::cout.flush();
d1 = m.mk_empty(5);
// TODO: make a more complicated mk_filter_identical example
}
static void tst7() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d2(m), d3(m);
d2 = m.mk_empty(3);
add_triple(m, d2, 15, 22, 15, 23, 7, 18);
add_triple(m, d2, 28, 42, 29, 39, 34, 46);
add_triple(m, d2, 28, 42, 29, 39, 100, 200);
add_triple(m, d2, 28, 42, 50, 60, 100, 200);
std::cout << "mk_project\n";
std::cout << mk_ll_pp(d2, m) << "\n";
unsigned vars[1] = {1};
m.mk_project(d2, d3, 1, vars);
std::cout << mk_ll_pp(d3, m) << "\n";
}
static void tst8() {
std::cout << "--------------------------------\n";
// enable_trace("mk_swap_bug");
imdd_manager m;
imdd_ref d2(m), d3(m);
d2 = m.mk_empty(3);
add_triple(m, d2, 15, 22, 15, 23, 7, 18);
add_triple(m, d2, 28, 42, 29, 39, 34, 46);
add_triple(m, d2, 28, 42, 29, 39, 100, 200);
add_triple(m, d2, 28, 42, 50, 60, 100, 200);
std::cout << mk_ll_pp(d2, m) << "\n";
m.mk_swap(d2, d3, 0);
std::cout << "after swap 0<->1\n";
std::cout << mk_ll_pp(d3, m) << "\n";
m.mk_swap(d2, d3, 1);
std::cout << "after swap 1<->2\n";
std::cout << mk_ll_pp(d3, m) << "\n";
}
static void tst9() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d2(m), d3(m);
d2 = m.mk_empty(5);
add_5tuple(m, d2, 2,2, 3,3, 1, 1, 5, 10, 100, 200);
std::cout << mk_ll_pp(d2, m) << "\n";
add_5tuple(m, d2, 2,2, 3,3, 1, 1, 15, 20, 100, 200);
std::cout << mk_ll_pp(d2, m) << "\n";
add_5tuple(m, d2, 4,4, 5,5, 1, 1, 5, 10, 100, 200);
std::cout << mk_ll_pp(d2, m) << "\n";
add_5tuple(m, d2, 4,4, 5,5, 1, 1, 15, 20, 100, 200);
std::cout << mk_ll_pp(d2, m) << "\n";
m.mk_swap(d2, d3, 2);
std::cout << "after swap 2<->3\n";
std::cout << mk_ll_pp(d3, m) << "\n";
}
static void tst10() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d1(m), d2(m), d3(m);
d1 = m.mk_empty(3);
add_triple(m, d1, 5, 100, 10, 20, 3, 10);
add_triple(m, d1, 5, 100, 34, 50, 98, 110);
m.add_bounded_var(d1, d2, 0, 66, 72);
std::cout << mk_ll_pp(d1, m) << "\n";
std::cout << mk_ll_pp(d2, m) << "\n";
m.add_bounded_var(d1, d3, 1, 64, 73);
std::cout << mk_ll_pp(d3, m) << "\n";
}
static void tst11() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d1(m), d2(m), d3(m);
d1 = m.mk_empty(3);
add_triple(m, d1, 5, 100, 10, 20, 3, 10);
add_triple(m, d1, 5, 100, 34, 50, 98, 110);
add_triple(m, d1, 20, 30, 5, 25, 11, 13);
m.mk_filter_distinct(d1, d2, 1, 2);
std::cout << mk_ll_pp(d1, m) << "\n";
std::cout << "filter_distinct(1,2):\n";
std::cout << mk_ll_pp(d2, m) << "\n";
}
static void tst12() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d1(m), d2(m), d3(m);
d1 = m.mk_empty(3);
add_triple(m, d1, 1, 10, 5, 25, 10, 13);
m.mk_filter_distinct(d1, d2, 1, 2);
std::cout << mk_ll_pp(d1, m) << "\n";
std::cout << "filter_distinct(1,2):\n";
std::cout << mk_ll_pp(d2, m) << "\n";
}
static void tst13() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d1(m), d2(m), d3(m);
d1 = m.mk_empty(3);
add_triple(m, d1, 5, 25, 1, 10, 10, 13);
add_triple(m, d1, 5, 25, 20, 30, 10, 13);
m.mk_filter_distinct(d1, d2, 0, 2);
std::cout << mk_ll_pp(d1, m) << "\n";
std::cout << "filter_distinct(0,2):\n";
std::cout << mk_ll_pp(d2, m) << "\n";
}
static void tst14() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d1(m), d2(m), d3(m);
d1 = m.mk_empty(3);
add_triple(m, d1, 5, 25, 1, 10, 10, 13);
add_triple(m, d1, 5, 25, 20, 30, 15, 18);
std::cout << "destructive version\n";
std::cout << mk_ll_pp(d1, m) << "\n";
m.mk_filter_distinct_dupdt(d1, 0, 2);
std::cout << "filter_distinct(0,2):\n";
std::cout << mk_ll_pp(d1, m) << "\n";
}
static void tst15() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d1(m), d2(m), d3(m);
d1 = m.mk_empty(3);
add_triple(m, d1, 5, 5, 1, 10, 5, 5);
std::cout << mk_ll_pp(d1, m) << "\n";
m.mk_filter_distinct(d1, d2, 0, 2);
std::cout << "filter_distinct(0,2):\n";
std::cout << mk_ll_pp(d2, m) << "\n";
}
static void tst16() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d1(m), d2(m), d3(m);
d1 = m.mk_empty(3);
add_triple(m, d1, 5, 15, 1, 10, 50, 500);
std::cout << mk_ll_pp(d1, m) << "\n";
m.mk_filter_disequal(d1, d2, 1, 4);
std::cout << "filter_disequal(var1,4):\n";
std::cout << mk_ll_pp(d2, m) << "\n";
}
static void tst17() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d1(m), d2(m), d3(m);
d1 = m.mk_empty(3);
add_triple(m, d1, 5, 15, 10, 10, 50, 500);
std::cout << mk_ll_pp(d1, m) << "\n";
m.mk_filter_disequal(d1, d2, 1, 10);
std::cout << "filter_disequal(var1,10):\n";
std::cout << mk_ll_pp(d2, m) << "\n";
}
static void tst18() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d1(m), d2(m), d3(m);
d1 = m.mk_empty(2);
add_pair(m, d1, 1112, 1290, 1302, 1302);
std::cout << mk_ll_pp(d1, m) << "\n";
m.mk_swap(d1, d2, 0);
std::cout << "mk_swap 0:\n";
std::cout << mk_ll_pp(d2, m) << "\n";
}
static void tst19() {
std::cout << "--------------------------------\n";
imdd_manager m;
imdd_ref d2(m), d3(m);
d2 = m.mk_empty(3);
add_triple(m, d2, 15, 22, 15, 23, 7, 18);
add_triple(m, d2, 28, 42, 29, 39, 34, 46);
add_triple(m, d2, 28, 42, 29, 39, 100, 200);
add_triple(m, d2, 28, 42, 50, 60, 100, 200);
std::cout << "mk_project_dupdt\n";
std::cout << mk_ll_pp(d2, m) << "\n";
unsigned vars[1] = {1};
m.mk_project_dupdt(d2, 1, vars);
std::cout << "new table\n";
std::cout << mk_ll_pp(d2, m) << "\n";
}
static void init(unsigned* v, unsigned a, unsigned b, unsigned c) {
v[0] = a;
v[1] = b;
v[2] = c;
}
static void tst20() {
std::cout << "--------------------------------\n";
std::cout << "remove_facts\n";
imdd_manager m;
imdd_ref d2(m), d3(m);
d2 = m.mk_empty(3);
add_triple(m, d2, 15, 22, 15, 23, 7, 18);
add_triple(m, d2, 28, 42, 29, 39, 34, 46);
add_triple(m, d2, 28, 42, 29, 39, 100, 200);
add_triple(m, d2, 28, 42, 50, 60, 100, 200);
std::cout << mk_ll_pp(d2, m) << "\n";
//
// [15, 22] -> #1:{
// [15, 23] -> {[7, 18]}*$80}*$80
// [28, 42] -> #2:{
// [29, 39] -> {[34, 46], [100, 200]}*$160
// [50, 60] -> {[100, 200]}*$80}*$80}$80
//
unsigned lowers[3] = {23,1,1};
unsigned uppers[3] = {24,1,1};
m.remove_facts(d2, d3, 3, lowers, uppers);
std::cout << "new table (no change)\n";
std::cout << mk_ll_pp(d3, m) << "\n";
lowers[0] = 22;
m.remove_facts(d2, d3, 3, lowers, uppers);
std::cout << "new table (no change)\n";
std::cout << mk_ll_pp(d3, m) << "\n";
init(lowers, 22, 15, 0);
init(uppers, 24, 23, 0);
m.remove_facts(d2, d3, 3, lowers, uppers);
std::cout << "new table (no change)\n";
std::cout << mk_ll_pp(d3, m) << "\n";
init(lowers, 22, 15, 7);
init(uppers, 24, 23, 18);
m.remove_facts(d2, d3, 3, lowers, uppers);
std::cout << "new table (narrow first interval)\n";
std::cout << mk_ll_pp(d3, m) << "\n";
init(lowers, 22, 15, 8);
init(uppers, 24, 23, 18);
m.remove_facts(d2, d3, 3, lowers, uppers);
std::cout << "new table (split first interval)\n";
std::cout << mk_ll_pp(d3, m) << "\n";
init(lowers, 22, 15, 8);
init(uppers, 24, 23, 17);
m.remove_facts(d2, d3, 3, lowers, uppers);
std::cout << "new table (split first interval)\n";
std::cout << mk_ll_pp(d3, m) << "\n";
init(lowers, 22, 15, 8);
init(uppers, 24, 23, 19);
m.remove_facts(d2, d3, 3, lowers, uppers);
std::cout << "new table (split first interval)\n";
std::cout << mk_ll_pp(d3, m) << "\n";
init(lowers, 30, 20, 120);
init(uppers, 40, 60, 140);
m.remove_facts(d2, d3, 3, lowers, uppers);
std::cout << "new table (split second interval)\n";
std::cout << mk_ll_pp(d3, m) << "\n";
}
static void tst21() {
std::cout << "--------------------------------\n";
std::cout << "remove_facts\n";
imdd_manager m;
imdd_ref d2(m), d3(m);
d2 = m.mk_empty(3);
add_triple(m, d2, 15, 22, 15, 23, 7, 18);
add_triple(m, d2, 28, 42, 29, 39, 34, 46);
add_triple(m, d2, 28, 42, 29, 39, 100, 200);
add_triple(m, d2, 28, 42, 50, 60, 100, 200);
std::cout << mk_ll_pp(d2, m) << "\n";
//
// [15, 22] -> #1:{
// [15, 23] -> {[7, 18]}*$80}*$80
// [28, 42] -> #2:{
// [29, 39] -> {[34, 46], [100, 200]}*$160
// [50, 60] -> {[100, 200]}*$80}*$80}$80
//
unsigned lowers[3] = {23,1,1};
unsigned uppers[3] = {24,1,1};
d3 = d2;
m.remove_facts_dupdt(d2, 3, lowers, uppers);
std::cout << "new table (no change)\n";
std::cout << mk_ll_pp(d2, m) << "\n";
d2 = d3;
lowers[0] = 22;
m.remove_facts_dupdt(d2, 3, lowers, uppers);
std::cout << "new table (no change)\n";
std::cout << mk_ll_pp(d2, m) << "\n";
init(lowers, 22, 15, 0);
init(uppers, 24, 23, 0);
m.remove_facts_dupdt(d2, 3, lowers, uppers);
std::cout << "new table (no change)\n";
std::cout << mk_ll_pp(d2, m) << "\n";
init(lowers, 22, 15, 7);
init(uppers, 24, 23, 18);
m.remove_facts_dupdt(d2, 3, lowers, uppers);
std::cout << "new table (narrow first interval)\n";
std::cout << mk_ll_pp(d2, m) << "\n";
init(lowers, 22, 15, 8);
init(uppers, 24, 23, 18);
m.remove_facts_dupdt(d2, 3, lowers, uppers);
std::cout << "new table (split first interval)\n";
std::cout << mk_ll_pp(d2, m) << "\n";
init(lowers, 22, 15, 8);
init(uppers, 24, 23, 17);
m.remove_facts_dupdt(d2, 3, lowers, uppers);
std::cout << "new table (split first interval)\n";
std::cout << mk_ll_pp(d2, m) << "\n";
init(lowers, 22, 15, 8);
init(uppers, 24, 23, 19);
m.remove_facts_dupdt(d2, 3, lowers, uppers);
std::cout << "new table (split first interval)\n";
std::cout << mk_ll_pp(d2, m) << "\n";
init(lowers, 30, 20, 120);
init(uppers, 40, 60, 140);
m.remove_facts_dupdt(d2, 3, lowers, uppers);
std::cout << "new table (split second interval)\n";
std::cout << mk_ll_pp(d2, m) << "\n";
}
static void tst22() {
std::cout << "--------------------------------\n";
std::cout << "swap\n";
imdd_manager m;
imdd_ref d2(m), d3(m), d4(m);
d2 = m.mk_empty(3);
random_gen rand;
for (unsigned i = 0; i < 130; ++i) {
unsigned a = rand(20);
unsigned b = rand(20);
unsigned c = rand(20);
add_triple(m, d2, a, a, b, b, c, c);
}
std::cout << mk_ll_pp(d2, m) << "\n";
m.mk_swap(d2, d3, 0, true);
std::cout << mk_ll_pp(d3, m) << "\n";
m.mk_swap(d3, d4, 0, true);
std::cout << mk_ll_pp(d4, m) << "\n";
SASSERT(m.is_subset(d2, d4));
SASSERT(m.is_subset(d4, d2));
}
void tst_imdd() {
// enable_trace("imdd_add_bug");
// enable_trace("add_facts_bug");
enable_trace("mk_distinct_imdd");
enable_trace("mk_union_core");
tst22();
tst0();
tst1();
tst2();
tst3();
tst4();
tst5();
tst6();
tst7();
tst19();
tst8();
tst9();
tst10();
tst11();
tst12();
tst13();
tst14();
tst15();
tst16();
tst17();
tst18();
tst20();
tst21();
}
#else
void tst_imdd() {
}
#endif

716
src/test/interval_skip_list.cpp
View file

@ -1,716 +0,0 @@
/*++
Copyright (c) 2006 Microsoft Corporation
Module Name:
interval_skip_list.cpp
Abstract:
<abstract>
Author:
Leonardo de Moura (leonardo) 2010-10-05.
Revision History:
--*/
#include"interval_skip_list.h"
#include"map.h"
#include"vector.h"
typedef sl_manager_base<unsigned> slist_manager;
template class interval_skip_list<unsigned_interval_skip_list_traits<unsigned, default_eq<unsigned>, 4, 4, false, slist_manager> >;
typedef interval_skip_list<unsigned_interval_skip_list_traits<unsigned, default_eq<unsigned>, 4, 4, false, slist_manager> > slist;
typedef u_map<unsigned> u2u_map;
typedef unsigned_isp_set<4, 4, slist_manager> uset;
static void tst1() {
slist_manager m;
slist l(m);
SASSERT(l.check_invariant());
SASSERT(l.empty());
// l.display_physical(std::cout);
l.insert(m, 20, 30, 5);
l.insert(m, 31, 32, 5);
l.insert(m, 18, 19, 5);
// l.display_physical(std::cout);
SASSERT(l.check_invariant());
l.insert(m, 10, 15, 8);
SASSERT(l.check_invariant());
// l.display_physical(std::cout);
l.insert(m, 5, 25, 7);
SASSERT(l.check_invariant());
// l.display_physical(std::cout);
l.insert(m, 23, 27, 5);
// l.display_physical(std::cout);
SASSERT(l.check_invariant());
l.deallocate(m);
}
static void tst2() {
slist_manager(m);
slist l(m);
for(unsigned i = 0; i < 50; i++) {
l.insert(m,i,i,i*10);
}
// l.display_physical(std::cout);
SASSERT(l.check_invariant());
for (unsigned i = 0; i < 25; i++) {
l.insert(m,i*2,i*2+1,i*20+1);
}
// l.display_physical(std::cout);
SASSERT(l.check_invariant());
for (unsigned i = 0; i < 15; i++) {
l.insert(m,i*3,i*3+2,i*30+1);
}
SASSERT(l.check_invariant());
// l.display_physical(std::cout);
// l.compress(4);
// l.display_physical(std::cout);
SASSERT(l.check_invariant());
l.deallocate(m);
}
static bool check_interval(slist & l, unsigned k1, unsigned k2, unsigned val) {
for (unsigned i = k1; i <= k2; i++) {
DEBUG_CODE({
unsigned _val;
SASSERT(l.contains(i, _val) && _val == val);
});
}
return true;
}
static bool check_no_interval(slist & l, unsigned k1, unsigned k2) {
for (unsigned i = k1; i <= k2; i++) {
DEBUG_CODE({
unsigned _val;
SASSERT(!l.contains(i, _val));
});
}
return true;
}
static void tst4() {
slist_manager m;
slist l(m);
l.insert(m, 1, 10, 0);
l.insert(m, 2, 5, 1);
SASSERT(check_no_interval(l,0,0));
SASSERT(check_interval(l,1,1,0));
SASSERT(check_interval(l,2,5,1));
SASSERT(check_interval(l,6,10,0));
SASSERT(check_no_interval(l,11,20));
SASSERT(l.check_invariant());
l.deallocate(m);
}
static void tst5() {
slist_manager m;
slist l(m);
l.insert(m, 1, 5, 0);
l.insert(m, 8, 100, 1);
l.insert(m, 8, 20, 1);
SASSERT(check_no_interval(l,0,0));
SASSERT(check_interval(l,1,5,0));
SASSERT(check_no_interval(l,6,7));
SASSERT(check_interval(l,8,100,1));
SASSERT(check_no_interval(l,101,200));
SASSERT(l.check_invariant());
l.deallocate(m);
}
static void tst6() {
slist_manager m;
slist l(m);
l.insert(m, 1, 5, 0);
l.insert(m, 8, 100, 1);
l.insert(m, 3, 20, 1);
SASSERT(check_no_interval(l,0,0));
SASSERT(check_interval(l,1,2,0));
SASSERT(check_interval(l,3,100,1));
SASSERT(check_no_interval(l,101,200));
SASSERT(l.check_invariant());
l.deallocate(m);
}
static void tst7() {
slist_manager m;
slist l(m);
l.insert(m, 1, 5, 0);
l.insert(m, 8, 100, 1);
l.insert(m, 2, 12, 0);
SASSERT(check_no_interval(l,0,0));
SASSERT(check_interval(l,1,12,0));
SASSERT(check_interval(l,13,100,1));
SASSERT(check_no_interval(l,101,200));
SASSERT(l.check_invariant());
l.deallocate(m);
}
static void tst8() {
slist_manager m;
slist l(m);
for (unsigned i = 0; i < 100; i++) {
l.insert(m, 10*i, 10*i+5, i);
}
SASSERT(!l.empty());
l.insert(m, 0, 10000, 0);
SASSERT(!l.has_more_than_k_entries(1));
// l.display_physical(std::cout);
l.deallocate(m);
}
struct for_each_contains {
slist const & m_other;
for_each_contains(slist const & other):m_other(other) {}
bool operator()(unsigned b, unsigned e, unsigned v) {
for (unsigned i = b; i <= e; i++) {
DEBUG_CODE({
unsigned _v;
SASSERT(m_other.contains(i, _v));
SASSERT(v == _v);
});
}
return true;
}
};
static void random_tsts(unsigned num_ops, unsigned max_key, unsigned max_val, unsigned max_interval_size) {
slist_manager m;
slist m1(m);
u2u_map m2;
for (unsigned i = 0; i < num_ops; i++) {
SASSERT(m1.check_invariant());
TRACE("interval_skip_list", tout << "i: " << i << "\n"; m1.display_physical(tout););
// std::cout << i << std::endl;
int op = rand()%8;
if (op < 3) {
unsigned bg = rand() % max_key;
unsigned sz = rand() % max_interval_size;
if (sz == 0) sz = 1;
unsigned val = rand() % max_val;
m1.insert(m, bg, bg+sz, val);
for (unsigned j = bg; j <= bg+sz; j++) {
DEBUG_CODE({
unsigned _val;
SASSERT(m1.contains(j, _val));
CTRACE("interval_skip_list", val != _val, tout << "i: " << i << ", j: " << j << ", val: " << val << ", _val: " << _val << "\n"; m1.display_physical(tout););
SASSERT(val == _val);
TRACE("interval_skip_list", tout << "[insert]: " << j << " -> " << val << "\n";);
});
m2.insert(j, val);
}
}
else if (op < 4) {
unsigned bg = rand() % max_key;
unsigned sz = rand() % max_interval_size;
if (sz == 0) sz = 1;
m1.erase(m, bg, bg+sz);
for (unsigned i = bg; i <= bg+sz; i++) {
m2.erase(i);
}
}
else if (op < 5) {
slist m1_copy(m);
m1_copy.copy(m, m1);
for_each_contains proc1(m1);
for_each_contains proc2(m1_copy);
m1.for_each(proc2);
m1_copy.for_each(proc1);
// m1.display_physical(std::cout);
// std::cout << "COPY===>\n";
// m1_copy->display_physical(std::cout);
m1_copy.deallocate(m);
}
else if (op < 6) {
m1.compress(m, 3);
}
else {
SASSERT(m1.check_invariant());
u2u_map::iterator it = m2.begin();
u2u_map::iterator end = m2.end();
for (; it != end; ++it) {
DEBUG_CODE({
unsigned _val;
CTRACE("interval_skip_list", !m1.contains(it->m_key, _val),
tout << it->m_key << " -> " << it->m_value << "\n";
m1.display_physical(tout););
SASSERT(m1.contains(it->m_key, _val));
SASSERT(it->m_value == _val);
});
}
}
}
// m1.display_physical(std::cout);
// m1.compress(4);
// m1.display_physical(std::cout);
m1.deallocate(m);
}
static void tst9() {
slist_manager m;
slist l(m);
l.insert(m,10,10,1);
l.insert(m,9,9,0);
l.insert(m,8,8,2);
l.insert(m,7,7,3);
l.insert(m,6,8,3);
SASSERT(!l.has_more_than_k_buckets(1));
SASSERT(check_no_interval(l,0,5));
SASSERT(check_interval(l,6,8,3));
SASSERT(check_interval(l,9,9,0));
SASSERT(check_interval(l,10,10,1));
SASSERT(check_no_interval(l,11,20));
l.deallocate(m);
}
static void tst10() {
slist_manager m;
slist l(m);
l.insert(m,10,10,1);
l.insert(m,13,16,2);
l.insert(m,17,28,3);
l.remove(m,12,19);
SASSERT(l.check_invariant());
SASSERT(check_no_interval(l,0,9));
SASSERT(check_interval(l,10,10,1));
SASSERT(check_no_interval(l,12,19));
SASSERT(check_interval(l,20,28,3));
SASSERT(check_no_interval(l,29,100));
l.remove(m,10,11);
SASSERT(l.check_invariant());
SASSERT(check_no_interval(l,0,19));
SASSERT(check_interval(l,20,28,3));
SASSERT(check_no_interval(l,29,100));
l.remove(m,0,1000);
SASSERT(l.empty());
SASSERT(l.check_invariant());
l.deallocate(m);
}
static void tst11() {
slist_manager m;
slist l(m);
l.insert(m,11,20,1);
l.insert(m,21,30,2);
l.insert(m,31,40,3);
l.insert(m,41,50,4);
l.insert(m,51,60,5);
l.compress(m,4);
SASSERT(check_no_interval(l,0,10));
SASSERT(check_interval(l,11,20,1));
SASSERT(check_interval(l,21,30,2));
SASSERT(check_interval(l,31,40,3));
SASSERT(check_interval(l,41,50,4));
SASSERT(check_interval(l,51,60,5));
SASSERT(check_no_interval(l,61,100));
SASSERT(l.check_invariant());
l.remove(m, 25, 26);
SASSERT(check_no_interval(l,0,10));
SASSERT(check_interval(l,11,20,1));
SASSERT(check_interval(l,21,24,2));
SASSERT(check_no_interval(l,25,26));
SASSERT(check_interval(l,27,30,2));
SASSERT(check_interval(l,31,40,3));
SASSERT(check_interval(l,41,50,4));
SASSERT(check_interval(l,51,60,5));
SASSERT(check_no_interval(l,61,100));
SASSERT(l.check_invariant());
l.remove(m, 44,48);
SASSERT(check_no_interval(l,0,10));
SASSERT(check_interval(l,11,20,1));
SASSERT(check_interval(l,21,24,2));
SASSERT(check_no_interval(l,25,26));
SASSERT(check_interval(l,27,30,2));
SASSERT(check_interval(l,31,40,3));
SASSERT(check_interval(l,41,43,4));
SASSERT(check_no_interval(l,44,48));
SASSERT(check_interval(l,49,50,4));
SASSERT(check_interval(l,51,60,5));
SASSERT(check_no_interval(l,61,100));
SASSERT(l.check_invariant());
l.remove(m, 22,24);
SASSERT(check_no_interval(l,0,10));
SASSERT(check_interval(l,11,20,1));
SASSERT(check_interval(l,21,21,2));
SASSERT(check_no_interval(l,22,26));
SASSERT(check_interval(l,27,30,2));
SASSERT(check_interval(l,31,40,3));
SASSERT(check_interval(l,41,43,4));
SASSERT(check_no_interval(l,44,48));
SASSERT(check_interval(l,49,50,4));
SASSERT(check_interval(l,51,60,5));
SASSERT(check_no_interval(l,61,100));
SASSERT(l.check_invariant());
l.remove(m, 42,49);
SASSERT(check_no_interval(l,0,10));
SASSERT(check_interval(l,11,20,1));
SASSERT(check_interval(l,21,21,2));
SASSERT(check_no_interval(l,22,26));
SASSERT(check_interval(l,27,30,2));
SASSERT(check_interval(l,31,40,3));
SASSERT(check_interval(l,41,41,4));
SASSERT(check_no_interval(l,42,49));
SASSERT(check_interval(l,50,50,4));
SASSERT(check_interval(l,51,60,5));
SASSERT(check_no_interval(l,61,100));
SASSERT(l.check_invariant());
// l.display_physical(std::cout);
l.deallocate(m);
}
static void tst12() {
slist_manager m;
slist l(m);
l.insert(m,10,10,0);
l.insert(m,9,9,0);
SASSERT(l.check_invariant());
l.insert(m,8,9,1);
SASSERT(l.check_invariant());
l.insert(m,7,7,2);
SASSERT(l.check_invariant());
l.insert(m,6,6,3);
SASSERT(l.check_invariant());
l.insert(m,4,5,2);
SASSERT(l.check_invariant());
l.insert(m,3,9,0);
// l.display_physical(std::cout);
l.deallocate(m);
}
static void tst13() {
slist_manager m;
uset s(m);
s.insert(m, 10, 30);
s.insert(m, 32, 40);
s.display(std::cout);
std::cout << ", mem: " << s.memory() << "\n";
s.deallocate(m);
}
struct obj {
unsigned m_val;
unsigned m_ref_count;
void inc_ref() {
m_ref_count++;
}
void dec_ref() {
SASSERT(m_ref_count > 0);
m_ref_count--;
if (m_ref_count == 0)
dealloc(this);
}
obj(unsigned v):m_val(v), m_ref_count(0) {
}
};
std::ostream & operator<<(std::ostream & out, obj * o) {
out << o->m_val << "{" << o->m_ref_count << "}";
return out;
}
struct obj_slist_manager : public sl_manager_base<obj*> {
void inc_ref_eh(obj * v) {
v->inc_ref();
}
void dec_ref_eh(obj * v) {
v->dec_ref();
}
};
struct inc_ref_functor {
unsigned_vector & refs;
inc_ref_functor(unsigned_vector & r):refs(r) {}
bool operator()(unsigned b, unsigned e, obj * val) {
refs[val->m_val]++;
return true;
}
};
template class interval_skip_list<unsigned_interval_skip_list_traits<obj*, default_eq<obj*>, 16, 16, true, obj_slist_manager> >;
typedef interval_skip_list<unsigned_interval_skip_list_traits<obj*, default_eq<obj*>, 16, 16, true, obj_slist_manager> > obj_slist;
void random_tsts_ref(unsigned num_ops, unsigned num_objs, unsigned max_key, unsigned max_interval_size) {
obj_slist_manager m;
obj_slist l(m);
ptr_vector<obj> objs;
unsigned_vector refs;
for (unsigned i = 0; i < num_objs; i++) {
objs.push_back(alloc(obj, i));
objs.back()->inc_ref();
refs.push_back(1);
}
for (unsigned i = 0; i < num_ops; i++) {
SASSERT(l.check_invariant());
TRACE("interval_skip_list", tout << "i: " << i << "\n"; l.display_physical(tout); tout << "\n";);
int op = rand()%5;
if (op < 3) {
unsigned bg = rand() % max_key;
unsigned sz = rand() % max_interval_size;
if (sz == 0) sz = 1;
unsigned val = rand() % num_objs;
TRACE("interval_skip_list", tout << "[inserting]: [" << bg << ", " << (bg+sz) << "] -> " << objs[val] << "\n";);
l.insert(m, bg, bg+sz, objs[val]);
SASSERT(objs[val]->m_ref_count > 1);
}
else if (op < 4) {
unsigned bg = rand() % max_key;
unsigned sz = rand() % max_interval_size;
if (sz == 0) sz = 1;
TRACE("interval_skip_list", tout << "[erasing]: [" << bg << ", " << (bg+sz) << "]\n";);
l.erase(m, bg, bg+sz);
}
else if (op < 5) {
obj_slist l_copy(m);
l_copy.copy(m, l);
TRACE("interval_skip_list", tout << "[copying]\n";);
l_copy.deallocate(m);
TRACE("interval_skip_list", tout << "[deleting copy]\n";);
}
else {
TRACE("interval_skip_list", tout << "[compressing]\n";);
l.compress(m, 3);
}
// check ref-counts
inc_ref_functor proc(refs);
l.for_each(proc);
for (unsigned i = 0; i < num_objs; i++) {
CTRACE("interval_skip_list", refs[i] != objs[i]->m_ref_count,
tout << "i: " << i << ", objs[i]: " << objs[i] << ", refs[i]: " << refs[i] << "\n\n";
l.display_physical(tout););
SASSERT(refs[i] == objs[i]->m_ref_count);
refs[i] = 1;
}
}
l.deallocate(m);
for (unsigned i = 0; i < num_objs; i++) {
SASSERT(objs[i]->m_ref_count == 1);
objs[i]->dec_ref();
}
}
void tst_ref() {
obj_slist_manager m;
obj_slist l(m);
for (unsigned i = 0; i < 30; i++) {
obj * n = alloc(obj, i);
l.insert(m, i*10, i*10+3, n);
// l.display_physical(std::cout);
// std::cout << "memory: " << l.memory() << "\n";
}
l.deallocate(m);
}
void tst_push_back_aux(slist::push_back_proc & push_back, unsigned num_ops, unsigned max_int, unsigned max_sep, unsigned max_val) {
unsigned prev_key;
if (push_back.empty())
prev_key = 0;
else
prev_key = push_back.last_key();
for (unsigned i = 0; i < num_ops; i++) {
unsigned next_key = prev_key + 1;
next_key += (rand() % max_sep);
unsigned sz = rand() % max_int;
if (sz == 0) sz = 1;
unsigned val = rand() % max_val;
push_back(next_key, next_key+sz, val);
SASSERT(!push_back.empty());
prev_key = push_back.last_key();
}
}
void tst_push_back1(unsigned num_ops, unsigned max_int, unsigned max_sep, unsigned max_val) {
slist_manager m;
slist l(m);
slist::push_back_proc push_back(m, l);
tst_push_back_aux(push_back, num_ops, max_int, max_sep, max_val);
// l.display_physical(std::cout);
SASSERT(l.check_invariant());
l.deallocate(m);
}
void tst_push_back2(unsigned num_ops, unsigned max_int, unsigned max_sep, unsigned max_val) {
slist_manager m;
slist l(m);
// insert some random values before creating push_back functor
for (unsigned i = 0; i < num_ops; i++) {
unsigned next_key = rand() % (num_ops * max_int/2);
unsigned sz = rand() % max_int;
if (sz == 0) sz = 1;
unsigned val = rand() % max_val;
l.insert(m, next_key, next_key+sz, val);
}
slist::push_back_proc push_back(m, l);
tst_push_back_aux(push_back, num_ops, max_int, max_sep, max_val);
// l.display_physical(std::cout);
SASSERT(l.check_invariant());
l.deallocate(m);
}
void tst_find_geq1() {
slist_manager m;
slist l(m);
l.insert(m, 10, 20, 4);
l.insert(m, 23, 30, 3);
l.insert(m, 40, 45, 10);
l.insert(m, 50, 66, 1);
l.insert(m, 100, 120, 21);
l.insert(m, 140, 200, 2);
slist::iterator it = l.find_geq(22);
SASSERT(it->begin_key() == 23);
it = l.find_geq(42);
SASSERT(it->begin_key() == 40);
it.move_to(130);
SASSERT(it->begin_key() == 140);
it.move_to(400);
SASSERT(it == l.end());
it = l.find_geq(300);
SASSERT(it == l.end());
it = l.find_geq(9);
SASSERT(it->begin_key() == 10);
it.move_to(105);
SASSERT(it->begin_key() == 100);
it = l.find_geq(15);
SASSERT(it->begin_key() == 10);
it.move_to(31);
SASSERT(it->begin_key() == 40);
it = l.find_geq(22);
SASSERT(it->begin_key() == 23);
it = l.find_geq(124);
SASSERT(it->begin_key() == 140);
it = l.find_geq(102);
SASSERT(it->begin_key() == 100);
// l.display_physical(std::cout);
l.deallocate(m);
}
struct add42 {
unsigned operator()(unsigned v) { return v + 42; }
};
void tst_move_to() {
slist_manager m;
slist l(m);
for (unsigned i = 0; i < 500; i++)
l.insert(m, i*10, i*10 + 5, i);
l.compress(m, 4);
slist::iterator it = l.find_geq(137);
SASSERT(it->begin_key() == 140);
it.move_to(947);
SASSERT(it->begin_key() == 950);
it.move_to(4955);
SASSERT(it->begin_key() == 4950);
it.move_to(4955);
SASSERT(it->begin_key() == 4950);
it.move_to(4956);
SASSERT(it->begin_key() == 4960);
it.move_to(4982);
SASSERT(it->begin_key() == 4980);
it.move_to(4987);
SASSERT(it->begin_key() == 4990);
it.move_to(4990);
SASSERT(it->begin_key() == 4990);
it.move_to(4995);
SASSERT(it->begin_key() == 4990);
it.move_to(4996);
SASSERT(it.at_end());
// l.display_physical(std::cout);
add42 f;
// l.display(std::cout); std::cout << "\n";
l.update_values(m, f);
// l.display(std::cout); std::cout << "\n";
l.deallocate(m);
}
static void tst_ext_iterator() {
slist_manager m;
slist l(m);
for (unsigned i = 0; i < 20; i++)
l.insert(m, i*10, i*10 + 5, i);
l.compress(m, 4);
l.display_physical(std::cout); std::cout << "\n";
slist::ext_iterator it;
slist::ext_iterator end;
SASSERT(end.at_end());
l.move_geq(it, 92);
SASSERT(!it.at_end());
SASSERT(it->begin_key() == 90);
it++;
SASSERT(it->begin_key() == 100);
it.erase(m);
SASSERT(it->begin_key() == 110);
it.erase(m);
SASSERT(it->begin_key() == 120);
it.erase(m);
it.erase(m);
it.erase(m);
it.erase(m);
SASSERT(it->begin_key() == 160);
SASSERT(l.check_invariant());
l.display_physical(std::cout); std::cout << "\n";
l.move_geq(it, 0);
SASSERT(it->begin_key() == 0);
it.erase(m);
SASSERT(it->begin_key() == 10);
it.erase(m);
SASSERT(it->begin_key() == 20);
it.erase(m);
SASSERT(it->begin_key() == 30);
it.erase(m);
SASSERT(it->begin_key() == 40);
it.erase(m);
SASSERT(it->begin_key() == 50);
l.display_physical(std::cout); std::cout << "\n";
l.deallocate(m);
}
void tst_interval_skip_list() {
std::cout << "unsigned map stats:\n";
slist::display_size_info(std::cout);
std::cout << "\nunsigned set stats:\n";
uset::display_size_info(std::cout);
std::cout << "\n";
tst1();
// enable_trace("interval_skip_list_insert_bug");
// enable_trace("interval_skip_list_bug");
// enable_trace("del_entries_upto_bug");
// enable_trace("insert_inside_bug");
// enable_trace("insert_at_bug");
tst2();
tst4();
tst5();
tst6();
tst7();
tst8();
tst9();
tst10();
tst11();
tst12();
tst13();
tst_find_geq1();
tst_move_to();
tst_push_back1(300, 4, 2, 10);
tst_push_back2(300, 4, 2, 10);
random_tsts(1000, 20, 20, 5);
random_tsts_ref(1000, 20, 20, 5);
tst_ref();
tst_ext_iterator();
}

13
src/test/main.cpp
View file

@ -22,7 +22,7 @@
if (do_display_usage) \
std::cout << #MODULE << "\n"; \
for (int i = 0; i < argc; i++) \
if (strcmp(argv[i], #MODULE) == 0) { \
if (test_all || strcmp(argv[i], #MODULE) == 0) { \
enable_trace(#MODULE); \
enable_debug(#MODULE); \
timeit timeit(true, s.c_str()); \
@ -60,6 +60,7 @@ void display_usage() {
std::cout << " /h prints this message.\n";
std::cout << " /v:level be verbose, where <level> is the verbosity level.\n";
std::cout << " /w enable warning messages.\n";
std::cout << " /a run all unit tests that don't require arguments.\n";
#if defined(Z3DEBUG) || defined(_TRACE)
std::cout << "\nDebugging support:\n";
#endif
@ -71,7 +72,7 @@ void display_usage() {
#endif
}
void parse_cmd_line_args(int argc, char ** argv, bool& do_display_usage) {
void parse_cmd_line_args(int argc, char ** argv, bool& do_display_usage, bool& test_all) {
int i = 1;
while (i < argc) {
char * arg = argv[i];
@ -99,6 +100,9 @@ void parse_cmd_line_args(int argc, char ** argv, bool& do_display_usage) {
else if (strcmp(opt_name, "w") == 0) {
enable_warning_messages(true);
}
else if (strcmp(opt_name, "a") == 0) {
test_all = true;
}
#ifdef _TRACE
else if (strcmp(opt_name, "tr") == 0) {
if (!opt_arg)
@ -122,7 +126,8 @@ void parse_cmd_line_args(int argc, char ** argv, bool& do_display_usage) {
int main(int argc, char ** argv) {
memory::initialize(0);
bool do_display_usage = false;
parse_cmd_line_args(argc, argv, do_display_usage);
bool test_all = false;
parse_cmd_line_args(argc, argv, do_display_usage, test_all);
TST(random);
TST(vector);
TST(symbol_table);
@ -151,7 +156,6 @@ int main(int argc, char ** argv) {
TST(simple_parser);
TST(api);
TST(old_interval);
TST(interval_skip_list);
TST(no_overflow);
TST(memory);
TST(get_implied_equalities);
@ -170,7 +174,6 @@ int main(int argc, char ** argv) {
TST(dl_util);
TST(dl_product_relation);
TST(dl_relation);
TST(imdd);
TST(parray);
TST(stack);
TST(escaped);