int main() {
for(int j=0;j < 3; j++) {
VC vc = vc_createValidityChecker();
vc_setFlags(vc,'n');
vc_setFlags(vc,'d');
vc_setFlags(vc,'p');
vc_setFlags(vc,'x');
Type bv8 = vc_bvType(vc, 8);
Expr a = vc_bvCreateMemoryArray(vc, "a");
Expr index_3 = vc_bvConstExprFromLL(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 cast_32_to_8 = vc_bvExtract(vc, a_of_0, 7, 0);
Expr cast_8_to_32 = vc_bvSignExtend(vc, cast_32_to_8, 32);
vc_printExpr(vc, cast_8_to_32);
cast_8_to_32 = vc_simplify(vc, cast_8_to_32);
vc_Destroy(vc);
}
}
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);
}
// 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");
}
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);
}
Expr vc_bvReadMemoryArray(VC vc,
Expr array,
Expr byteIndex, int numOfBytes) {
if(!(numOfBytes > 0))
BEEV::FatalError("numOfBytes must be greater than 0");
if(numOfBytes == 1)
return vc_readExpr(vc,array,byteIndex);
else {
int count = 1;
Expr a = vc_readExpr(vc,array,byteIndex);
while(--numOfBytes > 0) {
Expr b = vc_readExpr(vc,array,
/*vc_simplify(vc, */
vc_bvPlusExpr(vc, 32,
byteIndex,
vc_bvConstExprFromInt(vc,32,count)))/*)*/;
a = vc_bvConcatExpr(vc,b,a);
count++;
}
return a;
}
}
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!
}
