TEST(push_pop, one)
{
VC vc = vc_createValidityChecker();
vc_setFlags(vc, 'n');
vc_setFlags(vc, 'd');
vc_setFlags(vc, 'p');
// vc_setFlags(vc,'v');
// vc_setFlags(vc,'s');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_varExpr(vc, "a", bv8);
Expr ct_0 = vc_bvConstExprFromInt(vc, 8, 0);
Expr a_eq_0 = vc_eqExpr(vc, a, ct_0);
int query = vc_query(vc, a_eq_0);
printf("query = %d\n", query);
vc_push(vc);
query = vc_query(vc, a_eq_0);
vc_pop(vc);
printf("query = %d\n", query);
vc_DeleteExpr(a_eq_0);
vc_DeleteExpr(a);
vc_Destroy(vc);
// FIXME: Actually test something
// ASSERT_TRUE(false && "FIXME: Actually test something");
}
int main() {
VC vc = vc_createValidityChecker();
vc_setFlags(vc,'n');
vc_setFlags(vc,'c');
vc_setFlags(vc,'d');
vc_setFlags(vc,'p');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_varExpr(vc, "a", bv8);
Expr ct_0 = vc_bvConstExprFromInt(vc, 8, 0);
Expr a_eq_0 = vc_eqExpr(vc, a, ct_0);
/* Query 1 */
vc_push(vc);
int query = vc_query(vc, a_eq_0);
vc_pop(vc);
printf("query = %d\n", query);
/* Query 2 */
Expr a_neq_0 = vc_notExpr(vc, a_eq_0);
vc_push(vc);
query = vc_query(vc, a_neq_0);
vc_pop(vc);
printf("query = %d\n", query);
vc_Destroy(vc);
return 0;
}
TEST(push_pop, one)
{
VC vc = vc_createValidityChecker();
//vc_setFlags(vc, 'n');
vc_setFlags(vc, 'd');
//vc_setFlags(vc, 'p');
// vc_setFlags(vc,'v');
// vc_setFlags(vc,'s');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_varExpr(vc, "a", bv8);
Expr ct_0 = vc_bvConstExprFromInt(vc, 8, 0);
Expr a_eq_0 = vc_eqExpr(vc, a, ct_0);
int query = vc_query(vc, a_eq_0);
ASSERT_FALSE(query);
vc_push(vc);
query = vc_query(vc, a_eq_0);
ASSERT_FALSE(query);
vc_pop(vc);
vc_DeleteExpr(a_eq_0);
vc_DeleteExpr(a);
vc_Destroy(vc);
}
TEST(multiple_queries,one) {
VC vc = vc_createValidityChecker();
vc_setFlags(vc,'n');
vc_setFlags(vc,'c');
vc_setFlags(vc,'d');
vc_setFlags(vc,'p');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_varExpr(vc, "a", bv8);
Expr ct_0 = vc_bvConstExprFromInt(vc, 8, 0);
Expr a_eq_0 = vc_eqExpr(vc, a, ct_0);
/* Query 1 */
vc_push(vc);
int query = vc_query(vc, a_eq_0);
vc_pop(vc);
printf("query = %d\n", query);
/* Query 2 */
Expr a_neq_0 = vc_notExpr(vc, a_eq_0);
vc_push(vc);
query = vc_query(vc, a_neq_0);
vc_pop(vc);
printf("query = %d\n", query);
vc_Destroy(vc);
ASSERT_TRUE(false && "FIXME: Actually test something");
}
int main() {
VC vc = vc_createValidityChecker();
vc_setFlags('n');
vc_setFlags('d');
//vc_setFlags('p');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_bvCreateMemoryArray(vc, "a");
Expr index_3 = vc_bvConstExprFromInt(vc, 32, 3);
Expr a_of_0 = vc_readExpr(vc, a, index_3);
int i;
for (i = 2; i >= 0; i--)
a_of_0 = vc_bvConcatExpr(vc,
a_of_0,
vc_readExpr(vc, a,
vc_bvConstExprFromInt(vc, 32, i)));
Expr ct_5 = vc_bvConstExprFromInt(vc, 32, 5);
Expr a_of_0_div_5 = vc_bvDivExpr(vc, 32, a_of_0, ct_5);
Expr a_of_0_div_5_eq_5 = vc_eqExpr(vc, a_of_0_div_5, ct_5);
vc_printExpr(vc, a_of_0_div_5_eq_5); printf("\n");
/* Query 1 */
vc_push(vc);
int query = vc_query(vc, a_of_0_div_5_eq_5);
vc_pop(vc);
printf("query = %d\n", query);
vc_assertFormula(vc, a_of_0_div_5_eq_5);
vc_printExpr(vc, a_of_0_div_5_eq_5);
/* query(false) */
vc_push(vc);
query = vc_query(vc, vc_falseExpr(vc));
vc_pop(vc);
printf("query = %d\n", query);
assert(!query);
assert(vc_counterexample_size(vc));
int* a_val = (int*) malloc(sizeof *a_val);
char *p = (char*) a_val;
//a_of_1 = vc_simplify(vc, a_of_1); // BUG here
for (i=0; i<=3; i++) {
Expr elem = vc_readExpr(vc, a, vc_bvConstExprFromInt(vc, 32, i));
Expr ce = vc_getCounterExample(vc, elem);
unsigned long long v = getBVUnsigned(ce);
fprintf(stderr, "a[%d] = %ld\n", i, v);
*p = v; p++;
}
printf("a = %d\n", *a_val);
assert((*a_val)/5 == 5);
vc_Destroy(vc);
}
int main() {
VC vc = vc_createValidityChecker(NULL);
/* Prove that for integers x and y:
* x > 0 AND y > 0 => 2x + y >= 3 */
Type integer = vc_intType(vc);
Expr x = vc_varExpr(vc, "x", integer);
Expr y = vc_varExpr(vc, "y", integer);
Expr zero = vc_ratExpr(vc, 0, 1);
Expr x_positive = vc_gtExpr(vc, x, zero);
Expr y_positive = vc_gtExpr(vc, y, zero);
Expr two = vc_ratExpr(vc, 2, 1);
Expr twox = vc_multExpr(vc, two, x);
Expr twox_plus_y = vc_plusExpr(vc, twox, y);
Expr three = vc_ratExpr(vc, 3, 1);
Expr twox_plus_y_geq_3 = vc_geExpr(vc, twox_plus_y, three);
Expr formula = vc_impliesExpr(vc, vc_andExpr(vc, x_positive, y_positive),
twox_plus_y_geq_3);
char* formulaString = vc_printExprString(vc, formula);
printf("Checking validity of formula %s with CVC4.\n", formulaString);
printf("CVC4 should return 1 (meaning VALID).\n");
printf("Result from CVC4 is: %d\n", vc_query(vc, formula));
free(formulaString);
return 0;
}
void test5()
{
Flags flags = vc_createFlags();
VC vc;
Type r;
Expr x, xEQx, p;
// vc_setBoolFlag(flags, "proofs", TRUE);
vc = vc_createValidityChecker(flags);
r = vc_realType(vc);
x = vc_varExpr(vc, "x", r);
xEQx = vc_eqExpr(vc, x, x);
vc_query(vc, xEQx);
// p = vc_getProof(vc);
// vc_printExpr(vc, p);
vc_deleteType(r);
vc_deleteExpr(x);
vc_deleteExpr(xEQx);
// vc_deleteExpr(p);
vc_destroyValidityChecker(vc);
vc_deleteFlags(flags);
}
static SolverImpl::SolverRunStatus
runAndGetCex(::VC vc, STPBuilder *builder, ::VCExpr q,
const std::vector<const Array *> &objects,
std::vector<std::vector<unsigned char> > &values,
bool &hasSolution) {
// XXX I want to be able to timeout here, safely
hasSolution = !vc_query(vc, q);
if (hasSolution) {
values.reserve(objects.size());
for (std::vector<const Array *>::const_iterator it = objects.begin(),
ie = objects.end();
it != ie; ++it) {
const Array *array = *it;
std::vector<unsigned char> data;
data.reserve(array->size);
for (unsigned offset = 0; offset < array->size; offset++) {
ExprHandle counter =
vc_getCounterExample(vc, builder->getInitialRead(array, offset));
unsigned char val = getBVUnsigned(counter);
data.push_back(val);
}
values.push_back(data);
}
}
if (true == hasSolution) {
return SolverImpl::SOLVER_RUN_STATUS_SUCCESS_SOLVABLE;
} else {
return SolverImpl::SOLVER_RUN_STATUS_SUCCESS_UNSOLVABLE;
}
}
int main(int argc, char *argv[]) {
VC vc = vc_createValidityChecker();
vc_setFlags('n');
vc_setFlags('d');
vc_setFlags('p');
Expr nresp1 = vc_varExpr(vc, "nresp1", vc_bv32Type(vc));
Expr packet_get_int0 = vc_varExpr(vc, "packet_get_int0", vc_bv32Type(vc));
Expr exprs[] = {
// nresp1 == packet_get_int0
vc_eqExpr(vc, nresp1, packet_get_int0),
// nresp1 > 0
vc_bvGtExpr(vc, nresp1, vc_bv32ConstExprFromInt(vc, 0))
};
Expr res = vc_andExprN(vc, exprs, sizeof(exprs)/sizeof(exprs[0]));
vc_printExpr(vc, res);
int x = vc_query(vc, res);
printf("vc_query result = %d\n", x);
vc_printCounterExample(vc);
Expr cex = vc_getCounterExample(vc, res);
//vc_printExpr(vc, cex);
}
TEST(Leaks, boolean)
{
VC vc;
vc = vc_createValidityChecker();
Expr x = vc_varExpr(vc, "x", vc_boolType(vc));
Expr y = vc_varExpr(vc, "y", vc_boolType(vc));
Expr x_and_y = vc_andExpr(vc, x, y);
Expr not_x_and_y = vc_notExpr(vc, x_and_y);
Expr not_x = vc_notExpr(vc, x);
Expr not_y = vc_notExpr(vc, y);
Expr not_x_or_not_y = vc_orExpr(vc, not_x, not_y);
Expr equiv = vc_iffExpr(vc, not_x_and_y, not_x_or_not_y);
printf("%d\n", vc_query(vc, equiv));
vc_DeleteExpr(equiv);
vc_DeleteExpr(not_x_or_not_y);
vc_DeleteExpr(not_y);
vc_DeleteExpr(not_x);
vc_DeleteExpr(not_x_and_y);
vc_DeleteExpr(x_and_y);
vc_DeleteExpr(y);
vc_DeleteExpr(x);
vc_Destroy(vc);
}
TEST(push_pop, two)
{
VC vc = vc_createValidityChecker();
//vc_setFlags(vc, 'n');
vc_setFlags(vc, 'd');
//vc_setFlags(vc, 'p');
//vc_setFlags(vc, 'v');
//vc_setFlags(vc, 's');
vc_setFlags(vc, 'c');
vc_push(vc);
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_varExpr(vc, "a", bv8);
Expr ct_0 = vc_bvConstExprFromInt(vc, 8, 0);
Expr a_eq_0 = vc_eqExpr(vc, a, ct_0);
vc_assertFormula(vc, a_eq_0);
vc_printAsserts(vc);
vc_push(vc);
Expr queryexp = vc_eqExpr(vc, a, vc_bvConstExprFromInt(vc, 8, 0));
//vc_printExpr(vc, queryexp);
int query;
query = vc_query(vc, queryexp);
vc_printCounterExample(vc);
vc_pop(vc);
vc_pop(vc);
ASSERT_TRUE(query);
}
void handleQuery(VC handle, Expr queryExpr)
{
// Print the assertions
printf("Assertions:\n");
vc_printAsserts(handle, 0);
int result = vc_query(handle, queryExpr);
printf("Query:\n");
vc_printQuery(handle);
switch(result)
{
case 0: printf("Query is INVALID\n");
// print counter example
printf("Counter example:\n");
vc_printCounterExample(handle);
break;
case 1: printf("Query is VALID\n");break;
case 2: printf("Could not answer query\n");break;
case 3: printf("Timeout.\n"); break;
default: printf("Unhandled error\n");
}
printf("\n\n");
}
int main() {
VC vc = vc_createValidityChecker();
vc_setFlags('n');
vc_setFlags('d');
//vc_setFlags('p');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_bvCreateMemoryArray(vc, "a");
Expr index_1 = vc_bvConstExprFromInt(vc, 32, 1);
Expr a_of_1 = vc_readExpr(vc, a, index_1);
Expr ct_100 = vc_bvConstExprFromInt(vc, 8, 100);
Expr a_of_1_eq_100 = vc_eqExpr(vc, a_of_1, ct_100);
/* Query 1 */
vc_push(vc);
int query = vc_query(vc, a_of_1_eq_100);
vc_pop(vc);
printf("query = %d\n", query);
vc_assertFormula(vc, a_of_1_eq_100);
/* query(false) */
vc_push(vc);
query = vc_query(vc, vc_falseExpr(vc));
vc_pop(vc);
printf("query = %d\n", query);
if (vc_counterexample_size(vc) == 0) {
printf("Counterexample size is 0\n");
exit(1);
}
a_of_1 = vc_simplify(vc, a_of_1);
//vc_printExpr(vc, a_of_1);
Expr ce = vc_getCounterExample(vc, a_of_1);
unsigned long long v = getBVUnsigned(ce);
fprintf(stderr, "a[1] = %ld\n", v);
vc_Destroy(vc);
}
TEST(stp_counterex,one) {
VC vc = vc_createValidityChecker();
vc_setFlags(vc,'n');
vc_setFlags(vc,'d');
//vc_setFlags(vc,'p');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_bvCreateMemoryArray(vc, "a");
Expr index_1 = vc_bvConstExprFromInt(vc, 32, 1);
Expr a_of_1 = vc_readExpr(vc, a, index_1);
Expr ct_100 = vc_bvConstExprFromInt(vc, 8, 100);
Expr a_of_1_eq_100 = vc_eqExpr(vc, a_of_1, ct_100);
/* Query 1 */
vc_push(vc);
int query = vc_query(vc, a_of_1_eq_100);
vc_pop(vc);
printf("query = %d\n", query);
vc_assertFormula(vc, a_of_1_eq_100);
/* query(false) */
vc_push(vc);
query = vc_query(vc, vc_falseExpr(vc));
vc_pop(vc);
printf("query = %d\n", query);
ASSERT_FALSE(vc_counterexample_size(vc) == 0);
a_of_1 = vc_simplify(vc, a_of_1);
//vc_printExpr(vc, a_of_1);
Expr ce = vc_getCounterExample(vc, a_of_1);
unsigned long long v = getBVUnsigned(ce);
fprintf(stderr, "a[1] = %llu\n", v);
vc_Destroy(vc);
// FIXME: we should test more things!
}
void test9 (void)
{
VC vc = vc_createValidityChecker (((void *) 0));
Type bv32 = vc_bvType (vc, 32);
Expr zero = vc_bvConstExprFromInt (vc, 32, 0);
Expr one = vc_bvConstExprFromInt (vc, 32, 1);
Expr a = vc_varExpr (vc, "a", bv32);
Expr three = vc_bvConstExprFromInt (vc, 32, 3);
Expr three64 = vc_bvSignExtend (vc, three, 64);
Expr a64 = vc_bvSignExtend (vc, a, 64);
Expr prod64 = vc_bvMultExpr (vc, 64, a64, three64);
Expr min = vc_bvConstExprFromInt (vc, 32, (-2147483647 - 1));
Expr max = vc_bvConstExprFromInt (vc, 32, 2147483647);
Expr prod64_sge_min = vc_bvSGeExpr (vc, prod64, min);
Expr prod64_sle_max = vc_bvSLeExpr (vc, prod64, max);
Expr prod64_sge_min_and_sle_max =
vc_andExpr (vc, prod64_sge_min, prod64_sle_max);
vc_assertFormula (vc, prod64_sge_min_and_sle_max);
Expr D3 = vc_varExpr (vc, "D3", bv32);
Expr prod = vc_bvMultExpr (vc, 32, a, three);
Expr D3_eq_prod = vc_eqExpr (vc, D3, prod);
vc_assertFormula (vc, D3_eq_prod);
Expr D4 = vc_varExpr (vc, "D4", bv32);
Expr D3_sle_a_cond = vc_bvSLeExpr (vc, D3, a);
Expr D3_sle_a_expr = vc_iteExpr (vc, D3_sle_a_cond, one, zero);
Expr D4_eq_D3_sle_a_expr = vc_eqExpr (vc, D4, D3_sle_a_expr);
vc_assertFormula (vc, D4_eq_D3_sle_a_expr);
Expr D6 = vc_varExpr (vc, "D6", bv32);
Expr D3_slt_a_cond = vc_bvSLtExpr (vc, D3, a);
Expr D3_slt_a_expr = vc_iteExpr (vc, D3_slt_a_cond, one, zero);
Expr D6_eq_D3_slt_a_expr = vc_eqExpr (vc, D6, D3_slt_a_expr);
vc_assertFormula (vc, D6_eq_D3_slt_a_expr);
Expr zero_lt_a = vc_bvSLtExpr (vc, zero, a);
vc_assertFormula (vc, zero_lt_a);
Expr D4_eq_one = vc_eqExpr (vc, D4, one);
Expr not_D4_eq_one = vc_notExpr (vc, D4_eq_one);
vc_query (vc, not_D4_eq_one);
Expr D6_eq_one = vc_eqExpr (vc, D6, one);
Expr not_D6_eq_one = vc_notExpr (vc, D6_eq_one);
vc_query (vc, not_D6_eq_one);
vc_destroyValidityChecker(vc);
}
static unsigned timed_query(VC vc, Expr q, int line) {
static unsigned queryCounter = 0;
double start = getUserTime();
unsigned res = 0;
double delta = 0.;
res = vc_query(vc,q);
delta = getUserTime()-start;
printf("Q%d: %.2fs (%d)\n", queryCounter, delta, line);
queryCounter++;
return res;
}
TEST(sbdiv, one)
{
VC vc = vc_createValidityChecker();
vc_setFlags(vc, 'p');
Type int_type = vc_bv32Type(vc);
Expr zero = vc_bv32ConstExprFromInt(vc, 0);
Expr int_max = vc_bvConstExprFromInt(vc, 32, 0x7fffffff);
Expr a = vc_varExpr(vc, "a", int_type);
Expr b = vc_varExpr(vc, "b", int_type);
vc_assertFormula(vc, vc_sbvGtExpr(vc, b, zero));
vc_assertFormula(vc, vc_sbvLeExpr(vc, a, vc_sbvDivExpr(vc, 32, int_max, b)));
std::cout << vc_query(vc, vc_falseExpr(vc)) << std::endl;
// FIXME: Actually test something
// ASSERT_TRUE(false && "FIXME: Actually test something");
}
TEST(sbdiv, one)
{
VC vc = vc_createValidityChecker();
//vc_setFlags(vc, 'p');
vc_setFlags(vc, 'd');
Type int_type = vc_bv32Type(vc);
Expr zero = vc_bv32ConstExprFromInt(vc, 0);
Expr int_max = vc_bvConstExprFromInt(vc, 32, 0x7fffffff);
Expr a = vc_varExpr(vc, "a", int_type);
Expr b = vc_varExpr(vc, "b", int_type);
vc_assertFormula(vc, vc_sbvGtExpr(vc, b, zero));
vc_assertFormula(vc, vc_sbvLeExpr(vc, a, vc_sbvDivExpr(vc, 32, int_max, b)));
int query = vc_query(vc, vc_falseExpr(vc));
ASSERT_FALSE(query);
}
// FIXME: this test name sucks!
TEST(x,one) {
VC vc = vc_createValidityChecker();
vc_setFlags(vc,'n');
vc_setFlags(vc,'d');
vc_setFlags(vc,'p');
Expr nresp1 = vc_varExpr(vc, "nresp1", vc_bv32Type(vc));
Expr packet_get_int0 = vc_varExpr(vc, "packet_get_int0", vc_bv32Type(vc));
Expr sz = vc_varExpr(vc, "sz", vc_bv32Type(vc));
Expr d0,d1,d2;
Expr exprs[] = {
// nresp1 == packet_get_int0
vc_eqExpr(vc, nresp1, packet_get_int0),
// nresp1 > 0
vc_bvGtExpr(vc, nresp1, vc_bv32ConstExprFromInt(vc, 0)),
// sz == nresp1 * 4
vc_eqExpr(vc, sz, d0=vc_bv32MultExpr(vc, nresp1, vc_bv32ConstExprFromInt(vc, 4))),
// sz > nresp1 || sz < 0
vc_orExpr(vc, d1=vc_sbvGeExpr(vc, sz, nresp1), d2=vc_sbvLtExpr(vc, sz, vc_bv32ConstExprFromInt(vc, 0))),
};
Expr res = vc_andExprN(vc, exprs, sizeof(exprs)/sizeof(exprs[0]));
//vc_printExpr(vc, res);
vc_query(vc,res);
vc_DeleteExpr(nresp1);
vc_DeleteExpr(packet_get_int0);
vc_DeleteExpr(sz);
vc_DeleteExpr(d0);
vc_DeleteExpr(d1);
vc_DeleteExpr(d2);
vc_DeleteExpr(exprs[0]);
vc_DeleteExpr(exprs[1]);
vc_DeleteExpr(exprs[2]);
vc_DeleteExpr(exprs[3]);
vc_DeleteExpr(res);
vc_Destroy(vc);
// FIXME: Actually test something
//ASSERT_TRUE(false && "FIXME: Actually test something");
}
// FIXME: Pick a sensible testname that actually means something!
TEST(array_cvcl02,one) {
VC vc = vc_createValidityChecker();
vc_setFlag(vc,'n');
vc_setFlag(vc,'d');
vc_setFlag(vc,'p');
Expr cvcl_array = vc_varExpr1(vc, "a",32,32);
Expr i = vc_varExpr1(vc, "i", 0, 8);
Expr i32 = vc_bvConcatExpr(vc,
vc_bvConstExprFromStr(vc,
"000000000000000000000000"),
i);
Expr no_underflow = vc_bvLeExpr(vc,
vc_bvConstExprFromInt(vc, 32, 0),
i32);
Expr no_overflow = vc_bvLeExpr(vc,
i32,
vc_bvConstExprFromInt(vc, 32, 9));
Expr in_bounds = vc_andExpr(vc, no_underflow, no_overflow);
Expr a_of_i = vc_bvSignExtend(vc,
vc_readExpr(vc,cvcl_array,i32),
32);
Expr a_of_i_eq_11 = vc_eqExpr(vc,
vc_bvConcatExpr(vc,i32,a_of_i),
vc_bvConstExprFromInt(vc, 64, 11));
vc_assertFormula(vc, in_bounds);
vc_assertFormula(vc, a_of_i_eq_11);
vc_query(vc, vc_falseExpr(vc));
long long v;
Expr pre = vc_bvConstExprFromInt(vc,24,0);
int j;
for(j=0;j<10;j++) {
Expr exprj = vc_bvConstExprFromInt(vc,8,j);
Expr index = vc_bvConcatExpr(vc, pre, exprj);
index = vc_simplify(vc,index);
Expr a_of_j = vc_readExpr(vc, cvcl_array, index);
Expr ce = vc_getCounterExample(vc,a_of_j);
}
vc_Destroy(vc);
//vc_printCounterExample(vc);
// FIXME: Actually test something
//ASSERT_TRUE(false && "FIXME: Actually test something");
}
int check(VC vc, Expr e)
{
int res;
printf("Query: ");
vc_printExpr(vc, e);
check_error("Error occured during query");
res = vc_query(vc, e);
switch (res) {
case 0:
printf("Invalid\n\n");
break;
case 1:
printf("Valid\n\n");
break;
}
return res;
}
TEST(stp_array_model,one) {
VC vc = vc_createValidityChecker();
Expr a = vc_bvCreateMemoryArray(vc, "a");
Expr index_1 = vc_bvConstExprFromInt(vc, 32, 1);
Expr a_of_1 = vc_readExpr(vc, a, index_1);
Expr index_2 = vc_bvConstExprFromInt(vc, 32, 2);
Expr a_of_2 = vc_readExpr(vc, a, index_2);
Expr ct_42 = vc_bvConstExprFromInt(vc, 8, 42);
Expr a_of_1_eq_42 = vc_eqExpr(vc, a_of_1, ct_42);
Expr ct_77 = vc_bvConstExprFromInt(vc, 8, 77);
Expr a_of_2_eq_77 = vc_eqExpr(vc, a_of_2, ct_77);
vc_assertFormula(vc, a_of_1_eq_42);
vc_assertFormula(vc, a_of_2_eq_77);
/* query(false) */
ASSERT_TRUE(vc_query(vc, vc_falseExpr(vc)) == 0); // Should be invalid
ASSERT_FALSE(vc_counterexample_size(vc) == 0);
Expr *indices;
Expr *values;
int size;
vc_getCounterExampleArray(vc, a, &indices, &values, &size);
ASSERT_FALSE(size == 0); // No array entries
int j;
for (j = 0; j < size; ++j) {
Expr index = vc_getCounterExample(vc, indices[j]);
Expr value = vc_getCounterExample(vc, values[j]);
unsigned long long i = getBVUnsigned(index);
unsigned long long v = getBVUnsigned(value);
fprintf(stderr, "a[%llu] = %llu\n", i, v);
}
vc_Destroy(vc);
}
jboolean check(VC vc, Expr e)
{
//printf("Query: \n");
Expr notExpr = vc_notExpr(vc, e);
linkedlist_add(&exprPool, notExpr);
//vc_printExpr(vc,notExpr);
//fflush(stdout);
check_error("Error occured during query");
switch (vc_query(vc, notExpr)) {
case 0:
//printf("Invalid\n\n");
break;
case 1:
//printf("Valid\n\n");
return FALSE;
}
return TRUE;
}
void test10()
{
Flags flags = vc_createFlags();
VC vc = vc_createValidityChecker(flags);
Type a = vc_createType(vc, "a");
Type aa = vc_funType1(vc, a, a);
Op f1 = vc_createOp(vc, "f", aa);
Type aa2;
Op f2 = vc_lookupOp(vc, "f", &aa2);
FatalAssert(f2 != NULL, "Expected f2 not NULL");
FatalAssert(f1 == f2, "Expected equal");
Expr x = vc_varExpr(vc, "x", a);
Expr f1x = vc_funExpr1(vc, f1, x);
Expr f2x = vc_funExpr1(vc, f2, x);
Expr eq = vc_eqExpr(vc, f1x, f2x);
int res = vc_query(vc, eq);
printf("eq: %d\n", res);
vc_destroyValidityChecker(vc);
}
void go (enum ifaceflag_t f)
{
VC vc;
vc = vc_createValidityChecker ();
vc_setInterfaceFlags(vc, f, 0);
//vc_setFlags(vc,'s',0);
// CVC_FILE is a macro that expands to a file path
vc_parseExpr(vc, CVC_FILE);
Expr a = vc_varExpr(vc, "a", vc_bvType(vc, 8));
Expr ct_0 = vc_bvConstExprFromInt(vc, 8, 0);
Expr a_eq_0 = vc_eqExpr(vc, a, ct_0);
int query = vc_query(vc, a_eq_0);
vc_Destroy (vc);
ASSERT_TRUE(false && "FIXME: Actually test something");
}
TEST(push_pop, two)
{
VC vc = vc_createValidityChecker();
vc_setFlags(vc, 'n');
vc_setFlags(vc, 'd');
vc_setFlags(vc, 'p');
vc_setFlags(vc, 'v');
vc_setFlags(vc, 's');
vc_setFlags(vc, 'c');
vc_push(vc);
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_varExpr(vc, "a", bv8);
Expr ct_0 = vc_bvConstExprFromInt(vc, 8, 0);
Expr a_eq_0 = vc_eqExpr(vc, a, ct_0);
int query;
// query = vc_query(vc, a_eq_0);
// printf("query = %d\n", query);
Expr a_neq_0 = vc_notExpr(vc, a_eq_0);
vc_assertFormula(vc, a_eq_0);
vc_printAsserts(vc);
vc_push(vc);
Expr queryexp = vc_eqExpr(vc, a, vc_bvConstExprFromInt(vc, 8, 0));
vc_printExpr(vc, queryexp);
query = vc_query(vc, queryexp);
vc_printCounterExample(vc);
vc_pop(vc);
vc_pop(vc);
printf("query = %d\n", query);
// FIXME: Actually test something
// ASSERT_TRUE(false && "FIXME: Actually test something");
}
TEST(extend_adder_notexpr, one)
{
VC vc = vc_createValidityChecker();
vc_setFlags(vc, 'n');
vc_setFlags(vc, 'd');
// 8-bit variable 'x'
Expr x = vc_varExpr(vc, "x", vc_bvType(vc, 8));
// 32 bit constant value 1
Expr one = vc_bvConstExprFromInt(vc, 32, 1);
// 24 bit constant value 0
Expr bit24_zero = vc_bvConstExprFromInt(vc, 24, 0);
// 32 bit constant value 0
Expr bit32_zero = vc_bvConstExprFromInt(vc, 32, 0);
// Extending 8-bit variable to 32-bit value
Expr zero_concat_x = vc_bvConcatExpr(vc, bit24_zero, x);
Expr xp1 = vc_bvPlusExpr(vc, 32, zero_concat_x, one);
// Insteading of concat operation, I also tried with SignExtend
// Expr signextend_x=vc_bvSignExtend(vc,x,32);
// Expr xp1=vc_bvPlusExpr(vc,32,signextend_x,one);
// x+1=0
Expr eq = vc_eqExpr(vc, xp1, bit32_zero);
// x+1!=0
eq = vc_notExpr(vc, eq);
vc_query(vc, eq);
vc_printCounterExample(vc);
// FIXME: Actually test something
// ASSERT_TRUE(false && "FIXME: Actually test something");
}
void test8 (void)
{
Flags flags = vc_createFlags();
/* vc_setStrSeqFlag(flags, "trace", "pushpop", 1); */
/* vc_setStrSeqFlag(flags, "trace", "assertLit", 1); */
/* vc_setStrSeqFlag(flags, "trace", "assertFactCore", 1); */
/* vc_setStrSeqFlag(flags, "trace", "assertFormula", 1); */
VC vc = vc_createValidityChecker (flags);
Type bv32 = vc_bvType (vc, 32);
Expr zero = vc_bvConstExprFromInt (vc, 32, 0);
Expr one = vc_bvConstExprFromInt (vc, 32, 1);
Expr a = vc_varExpr (vc, "a", bv32);
Expr three = vc_bvConstExprFromInt (vc, 32, 3);
Expr prod = vc_bvMultExpr (vc, 32, a, three);
{
Expr a64 = vc_bvSignExtend (vc, a, 64);
Expr three64 = vc_bvSignExtend (vc, three, 64);
Expr prod64 = vc_bvMultExpr (vc, 64, a64, three64);
Expr max = vc_bvConstExprFromInt (vc, 32, 2147483647);
Expr min = vc_bvConstExprFromInt (vc, 32, (-2147483647 - 1));
Expr prod64_sge_min = vc_bvSGeExpr (vc, prod64, min);
Expr prod64_sle_max = vc_bvSLeExpr (vc, prod64, max);
Expr prod64_sge_min_and_sle_max =
vc_andExpr (vc, prod64_sge_min, prod64_sle_max);
vc_assertFormula (vc, prod64_sge_min_and_sle_max);
}
Expr D4 = vc_varExpr (vc, "D4", bv32);
{
Expr cond = vc_bvSLtExpr (vc, a, prod);
Expr test = vc_iteExpr (vc, cond, one, zero);
Expr D4_eq_test = vc_eqExpr (vc, D4, test);
vc_assertFormula (vc, D4_eq_test);
}
Expr D6 = vc_varExpr (vc, "D6", bv32);
{
Expr cond = vc_bvSLeExpr (vc, a, prod);
Expr test = vc_iteExpr (vc, cond, one, zero);
Expr D6_eq_test = vc_eqExpr (vc, D6, test);
vc_assertFormula (vc, D6_eq_test);
}
vc_push (vc);
vc_pop (vc);
vc_push (vc);
{
Expr cond = vc_bvSLtExpr (vc, a, zero);
Expr test = vc_iteExpr (vc, cond, one, zero);
Expr test_eq_one = vc_eqExpr (vc, test, one);
vc_assertFormula (vc, test_eq_one);
vc_push (vc);
{
Expr D4_eq_one = vc_eqExpr (vc, D4, one);
vc_query (vc, D4_eq_one);
}
vc_pop (vc);
vc_push (vc);
vc_pop (vc);
vc_push (vc);
vc_pop (vc);
}
vc_pop (vc);
{
Expr cond = vc_eqExpr (vc, a, zero);
Expr test = vc_iteExpr (vc, cond, one, zero);
Expr test_eq_one = vc_eqExpr (vc, test, one);
vc_assertFormula (vc, test_eq_one);
vc_push (vc);
vc_pop (vc);
{
Expr zero_eq_one = vc_eqExpr (vc, zero, one);
vc_query (vc, zero_eq_one);
}
}
vc_destroyValidityChecker(vc);
}
TEST(reported_issue_120, one)
{
VC vc = vc_createValidityChecker();
// Numbers will be non-negatives integers bounded at 2^32
Type bv32 = vc_bvType(vc, 32);
// Determine whether the following equations are satisfiable:
// v + 4 = n
// 4 = n
// Construct variable n
Expr n = vc_varExpr(vc, "n", bv32);
// Construct v + 4
Expr v = vc_varExpr(vc, "v", bv32);
Expr ct_4 = vc_bvConstExprFromInt(vc, 32, 4);
Expr add_v_4 = vc_bvPlusExpr(vc, 32, v, ct_4);
// Because numbers are represented as bit vectors,
// addition can roll over. So construct a constraint
// expresses that v+4 does not overflow the bounds:
// v + 4 >= v
//
Expr ge = vc_bvGeExpr(vc, add_v_4, v);
// Push a new context
printf("Push\n");
vc_push(vc);
// Assert v + 4 = n
printf("Assert v + 4 = n\n");
Expr f_add = vc_eqExpr(vc, add_v_4, n);
vc_assertFormula(vc, f_add);
vc_printExpr(vc, f_add);
printf("\n------\n");
// Assert the bounds constraint
printf("Assert v + 4 >= v\n");
vc_assertFormula(vc, ge);
vc_printExpr(vc, ge);
printf("\n------\n");
// Assert 4 = n
printf("Assert 4 = n\n");
Expr f_numeq = vc_eqExpr(vc, ct_4, n);
vc_assertFormula(vc, f_numeq);
vc_printExpr(vc, f_numeq);
printf("\n------\n");
// Check for satisfiability
printf("Check\n");
vc_printAsserts(vc);
printf("\n------\n");
int query = vc_query(vc, vc_falseExpr(vc));
ASSERT_EQ(query, 0);
// Pop context
printf("Pop\n");
vc_pop(vc);
printf("query = %d\n", query);
}
void test4(int regressLevel)
{
VC vc = vc_createValidityChecker(NULL);
// Check x >= 10 /\ x >= 40 /\ y <= 0 -->
// x >= 1 /\ y < 10
Type r = vc_realType(vc);
Expr x = vc_varExpr(vc, "x", r);
Expr y = vc_varExpr(vc, "y", r);
Expr ten = vc_ratExpr(vc, 10, 1);
Expr ge = vc_geExpr(vc, x, ten);
Expr forty = vc_ratExpr(vc, 40, 1);
Expr ge2 = vc_geExpr(vc, x, forty);
Expr zero = vc_ratExpr(vc, 0, 1);
Expr ge3 = vc_leExpr(vc, y, zero);
Expr children[3];
Expr hyp, one, conc, query;
int i;
children[0] = ge;
children[1] = ge2;
children[2] = ge3;
hyp = vc_andExprN(vc, children, 3);
vc_deleteType(r);
vc_deleteExpr(ge);
vc_deleteExpr(forty);
vc_deleteExpr(ge2);
vc_deleteExpr(zero);
vc_deleteExpr(ge3);
one = vc_ratExpr(vc, 1, 1);
ge = vc_geExpr(vc, x, one);
ge2 = vc_ltExpr(vc, y, ten);
conc = vc_andExpr(vc, ge, ge2);
query = vc_impliesExpr(vc, hyp, conc);
vc_deleteExpr(x);
vc_deleteExpr(y);
vc_deleteExpr(ten);
vc_deleteExpr(hyp);
vc_deleteExpr(one);
vc_deleteExpr(ge);
vc_deleteExpr(ge2);
vc_deleteExpr(conc);
for (i = 0; i < 100*regressLevel; i++)
vc_query(vc, query);
vc_deleteExpr(query);
vc_destroyValidityChecker(vc);
}
