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)))); }