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);
}
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(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");
}
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);
}
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;
}
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 test1()
{
Flags flags = vc_createFlags();
VC vc;
Type b;
Expr p, np, e;
Type r, real2real;
Expr x, y, fx, fy, xeqy, fxeqfy, w, z, weqx, yeqz, one, two, xeqone, xeqtwo,
simp, simp2;
Op f;
Expr* assertions;
int i, size, res;
Kind k;
vc_setStringFlag(flags, "dump-log", ".testc1.cvc");
vc_setStrSeqFlag(flags, "trace", "pushpop", 1);
vc = vc_createValidityChecker(flags);
// Check p OR ~p
b = vc_boolType(vc);
p = vc_varExpr(vc, "p", vc_boolType(vc));
np = vc_notExpr(vc, p);
e = vc_orExpr(vc, p, np);
res = check(vc, e);
FatalAssert(res == 1, "Expected Valid");
FatalAssert(vc_getKind(e) == OR, "Expected TRUE for kind check");
FatalAssert(vc_getKind(vc_getType(vc, e)) == BOOLEAN, "Expected TRUE for type kind check");
vc_deleteType(b);
vc_deleteExpr(p);
vc_deleteExpr(np);
vc_deleteExpr(e);
/* Check x = y -> f(x) = f(y) */
r = vc_realType(vc);
x = vc_varExpr(vc, "x", r);
y = vc_varExpr(vc, "y", r);
real2real = vc_funType1(vc, r, r);
f = vc_createOp(vc, "f", real2real);
fx = vc_funExpr1(vc, f, x);
fy = vc_funExpr1(vc, f, y);
xeqy = vc_eqExpr(vc, x, y);
fxeqfy = vc_eqExpr(vc, fx, fy);
e = vc_impliesExpr(vc, xeqy, fxeqfy);
res = check(vc, e);
FatalAssert(res == 1, "Expected Valid");
vc_deleteType(real2real);
vc_deleteExpr(e);
// Check f(x) = f(y) -> x = y
e = vc_impliesExpr(vc, fxeqfy, xeqy);
vc_push(vc);
res = check(vc, e);
FatalAssert(res == 0, "Expected Invalid");
vc_deleteExpr(e);
// Get counter-example
printf("Stack level: %d\n", vc_stackLevel(vc));
printf("Counter-example:\n");
assertions = vc_getCounterExample(vc, &size);
for (i = 0; i < size; ++i) {
vc_printExpr(vc, assertions[i]);
}
vc_deleteVector(assertions);
printf("End of counter-example\n\n");
printf("Concrete model:\n");
assertions = vc_getConcreteModel(vc, &size);
for (i = 0; i < size; ++i) {
vc_printExpr(vc, assertions[i]);
}
vc_deleteVector(assertions);
printf("End of concrete model\n\n");
// Reset to initial scope
printf("Resetting\n");
vc_pop(vc);
printf("Stack level: %d\n\n", vc_stackLevel(vc));
// Check w = x & x = y & y = z & f(x) = f(y) & x = 1 & z = 2
w = vc_varExpr(vc, "w", r);
z = vc_varExpr(vc, "z", r);
printf("Push Scope\n\n");
vc_push(vc);
weqx = vc_eqExpr(vc, w, x);
yeqz = vc_eqExpr(vc, y, z);
one = vc_ratExpr(vc, 1, 1);
two = vc_ratExpr(vc, 2, 1);
xeqone = vc_eqExpr(vc, x, one);
xeqtwo = vc_eqExpr(vc, x, two);
newAssertion(vc, weqx);
newAssertion(vc, xeqy);
newAssertion(vc, yeqz);
newAssertion(vc, fxeqfy);
newAssertion(vc, xeqone);
newAssertion(vc, xeqtwo);
printf("\nsimplify(w) = ");
simp = vc_simplify(vc, w);
char* str = vc_printExprString(vc, simp);
printf("%s\n", str);
vc_deleteString(str);
printf("Inconsistent?: %d\n", vc_inconsistent(vc, &assertions, &size));
check_error("Error occured during inconsistency check");
printf("Assumptions Used:\n");
for (i = 0; i < size; ++i) {
vc_printExpr(vc, assertions[i]);
}
vc_deleteVector(assertions);
printf("\nPop Scope\n\n");
vc_pop(vc);
printf("simplify(w) = ");
simp2 = vc_simplify(vc, w);
vc_printExpr(vc, simp2);
printf("\n");
printf("Inconsistent?: %d\n", vc_inconsistent(vc, &assertions, &size));
vc_deleteVector(assertions);
vc_deleteType(r);
vc_deleteExpr(x);
vc_deleteExpr(y);
vc_deleteOp(f);
vc_deleteExpr(fx);
vc_deleteExpr(fy);
vc_deleteExpr(xeqy);
vc_deleteExpr(fxeqfy);
vc_deleteExpr(w);
vc_deleteExpr(z);
vc_deleteExpr(weqx);
vc_deleteExpr(yeqz);
vc_deleteExpr(one);
vc_deleteExpr(two);
vc_deleteExpr(xeqone);
vc_deleteExpr(xeqtwo);
vc_deleteExpr(simp);
vc_deleteExpr(simp2);
vc_destroyValidityChecker(vc);
vc_deleteFlags(flags);
}
void test7()
{
VC vc = vc_createValidityChecker(NULL);
Type r = vc_realType(vc);
Type b = vc_boolType(vc);
Expr x = vc_varExpr(vc, "x", r);
Expr y = vc_varExpr(vc, "y", r);
Expr z = vc_varExpr(vc, "z", r);
Type real2real = vc_funType1(vc, r, r);
Type real2bool = vc_funType1(vc, r, b);
Op f = vc_createOp(vc, "f", real2real);
Op p = vc_createOp(vc, "p", real2bool);
Expr fx = vc_funExpr1(vc, f, x);
Expr fy = vc_funExpr1(vc, f, y);
Expr fxeqfy = vc_eqExpr(vc, fx, fy);
Expr px = vc_funExpr1(vc, p, x);
Expr py = vc_funExpr1(vc, p, y);
Expr xeqy = vc_eqExpr(vc, x, y);
Expr yeqx = vc_eqExpr(vc, y, x);
Expr xeqz = vc_eqExpr(vc, x, z);
Expr zeqx = vc_eqExpr(vc, z, x);
Expr yeqz = vc_eqExpr(vc, y, z);
Expr zeqy = vc_eqExpr(vc, z, y);
Expr notxeqz = vc_notExpr(vc, xeqz);
int c;
vc_registerAtom(vc, xeqy);
vc_registerAtom(vc, yeqx);
vc_registerAtom(vc, xeqz);
vc_registerAtom(vc, zeqx);
vc_registerAtom(vc, yeqz);
vc_registerAtom(vc, zeqy);
vc_registerAtom(vc, px);
vc_registerAtom(vc, py);
vc_registerAtom(vc, fxeqfy);
printf("Push\n");
vc_push(vc);
printf("Assert x = y\n");
vc_assertFormula(vc, xeqy);
c = printImpliedLiterals(vc);
FatalAssert(c==3,"Implied literal error 0");
printf("Push\n");
vc_push(vc);
printf("Assert x /= z\n");
vc_assertFormula(vc, notxeqz);
c = printImpliedLiterals(vc);
FatalAssert(c==4,"Implied literal error 1");
printf("Pop\n");
vc_pop(vc);
printf("Pop\n");
vc_pop(vc);
vc_deleteExpr(notxeqz);
vc_deleteExpr(zeqy);
vc_deleteExpr(yeqz);
vc_deleteExpr(zeqx);
vc_deleteExpr(xeqz);
vc_deleteExpr(yeqx);
vc_deleteExpr(xeqy);
vc_deleteExpr(py);
vc_deleteExpr(px);
vc_deleteExpr(fxeqfy);
vc_deleteExpr(fy);
vc_deleteExpr(fx);
vc_deleteOp(p);
vc_deleteOp(f);
vc_deleteType(real2bool);
vc_deleteType(real2real);
vc_deleteExpr(z);
vc_deleteExpr(y);
vc_deleteExpr(x);
vc_deleteType(b);
vc_deleteType(r);
vc_destroyValidityChecker(vc);
}
Expr parse()
{
char token[15];
Expr expr = NULL, leftExpr, rightExpr, eqExpr;
readToken(token);
switch(token[0]){
case '+':
leftExpr = parse();
rightExpr = parse();
expr = vc_plusExpr(vc, leftExpr, rightExpr);
break;
case '-':
if(token[1] == '\0'){
leftExpr = parse();
rightExpr = parse();
expr = vc_minusExpr(vc, leftExpr, rightExpr);
}
else{
// assert token[1] is a digit
expr = parseNumber(token);
}
break;
case '*':
leftExpr = parse();
rightExpr = parse();
expr = vc_multExpr(vc, leftExpr, rightExpr);
break;
case '<':
if (token[1] == '='){
leftExpr = parse();
rightExpr = parse();
expr = vc_leExpr(vc, leftExpr, rightExpr);
}
else{
leftExpr = parse();
rightExpr = parse();
expr = vc_ltExpr(vc, leftExpr, rightExpr);
}
break;
case '>':
if (token[1] == '='){
leftExpr = parse();
rightExpr = parse();
expr = vc_geExpr(vc, leftExpr, rightExpr);
}
else{
leftExpr = parse();
rightExpr = parse();
expr = vc_gtExpr(vc, leftExpr, rightExpr);
}
break;
case '=':
leftExpr = parse();
rightExpr = parse();
expr = vc_eqExpr(vc, leftExpr, rightExpr);
break;
case '!':
// assert token[1] == '=';
leftExpr = parse();
rightExpr = parse();
eqExpr = vc_eqExpr(vc, leftExpr, rightExpr);
linkedlist_add(&exprPool, eqExpr);
expr = vc_notExpr(vc, eqExpr);
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
expr = parseNumber(token);
break;
case 'x':
expr = hashmap_get(&vars, token);
if (expr == NULL){
expr = vc_varExpr(vc, token, intType);
char* token_copy = (char*) malloc(sizeof(char)*(strlen(token)+1));
strcpy(token_copy, token);
hashmap_put(&vars, token_copy, expr);
linkedlist_add(&exprPool, expr);
}
return expr;
case 'r':
expr = hashmap_get(&vars, token);
if (expr == NULL){
expr = vc_varExpr(vc, token, realType);
char* token_copy = (char*) malloc(sizeof(char)*(strlen(token)+1));
strcpy(token_copy, token);
hashmap_put(&vars, token_copy, expr);
linkedlist_add(&exprPool, expr);
}
return expr;
default:
printf( "%s", token);
throwRuntimeException( "unexpected type of token" );
}
linkedlist_add(&exprPool, expr);
return expr;
}
value caml_vc_notExpr(value vc, value e)
{
CAMLparam2(vc,e);
CAMLreturn(alloc_Expr(vc_notExpr(VC_val(vc),Expr_val(e))));
}
