int main ()
{
int rval;
int size;
struct file my_file;
char *buffer; /* we do not model this buffer */
struct inode inode;
unsigned int count;
unsigned char random;
int lock_held = 0;
dummy_major = register_chrdev (0, "dummy");
inode.i_rdev = dummy_major << MINORBITS;
init_module ();
/* assign arbitrary values */
my_file.f_mode = nondet_uint ();
my_file.f_pos = nondet_uint ();
do
{
random = nondet_uchar ();
__CPROVER_assume (0 <= random && random <= 3);
switch (random)
{
case 1:
rval = dummy_open (&inode, &my_file);
if (rval == 0)
lock_held = TRUE;
break;
case 2:
__CPROVER_assume (lock_held);
count = dummy_read (&my_file, buffer, BUF_SIZE);
break;
case 3:
dummy_release (&inode, &my_file);
lock_held = FALSE;
break;
default:
break;
}
}
while (random || lock_held);
cleanup_module ();
unregister_chrdev (dummy_major, "dummy");
return 0;
}
void d_div(){
unsigned int a, b, c;
a=nondet_uint();
b=nondet_uint();
int i;
if(a>0 || b>0){
for(i=0; i < 12; i++){
if (i == 11){
c=1/(a+b);
}
}
}
}
unsigned int sleep(unsigned int seconds)
{
// do nothing, but return nondet value
unsigned remaining_time=nondet_uint();
if(remaining_time>seconds) remaining_time=seconds;
return remaining_time;
}
int main() {
int i, j=10, n=nondet_uint(), sn=0;
for(i=1; i<=n; i++) {
if (i<j) //first case
sn = sn + a; //second case OK
j--;
//if (i==4) sn=-10; //third case OK
}
//__ESBMC_assume(i>n);
assert(sn==n*a || sn == 0);
}
int main(void)
{
mailbox_t *arr[] = {&m1, &m2, &m3};
unsigned int ndet = nondet_uint();
__CPROVER_assume(ndet < SIZE(arr));
/* __CPROVER_predicate(arr[0] == &m1);
__CPROVER_predicate(arr[1] == &m2);
__CPROVER_predicate(arr[2] == &m3);*/
__CPROVER_predicate(ndet == 0);
__CPROVER_predicate(ndet == 1);
__CPROVER_predicate(ndet == 2);
__CPROVER_assert(arr[ndet] == &m1 ||
arr[ndet] == &m2 ||
arr[ndet] == &m3, "E");
return 0;
}
int main() {
int *p;
unsigned o;
size_t n=nondet_uint();
__CPROVER_assume(n>=1);
__CPROVER_assume(n<10000000);
p=malloc(sizeof(int)*n);
o=n-1;
p[o]=1000;
assert(p[o]==1000);
free(p);
}
int main(void)
{
unsigned __CPROVER_bitvector[5] __cs_tmp_t0_r0 = (unsigned __CPROVER_bitvector[5])nondet_uint();
unsigned __CPROVER_bitvector[3] __cs_tmp_t1_r0 = (unsigned __CPROVER_bitvector[3])nondet_uint();
unsigned __CPROVER_bitvector[3] __cs_tmp_t2_r0 = (unsigned __CPROVER_bitvector[3])nondet_uint();
unsigned __CPROVER_bitvector[4] __cs_tmp_t3_r0 = (unsigned __CPROVER_bitvector[4])nondet_uint();
unsigned __CPROVER_bitvector[5] __cs_tmp_t4_r0 = (unsigned __CPROVER_bitvector[5])nondet_uint();
unsigned __CPROVER_bitvector[5] __cs_tmp_t0_r1 = (unsigned __CPROVER_bitvector[5])nondet_uint();
unsigned __CPROVER_bitvector[3] __cs_tmp_t1_r1 = (unsigned __CPROVER_bitvector[3])nondet_uint();
unsigned __CPROVER_bitvector[3] __cs_tmp_t2_r1 = (unsigned __CPROVER_bitvector[3])nondet_uint();
unsigned __CPROVER_bitvector[4] __cs_tmp_t3_r1 = (unsigned __CPROVER_bitvector[4])nondet_uint();
unsigned __CPROVER_bitvector[5] __cs_tmp_t4_r1 = (unsigned __CPROVER_bitvector[5])nondet_uint();
unsigned __CPROVER_bitvector[5] __cs_tmp_t0_r2 = (unsigned __CPROVER_bitvector[5])nondet_uint();
/* round 0 */
__CPROVER_assume(__cs_tmp_t0_r0 > 0);
__cs_thread_index = 0;
__cs_pc_cs[0] = __cs_pc[0] + __cs_tmp_t0_r0;
__CPROVER_assume(__cs_pc_cs[0] > 0);
__CPROVER_assume(__cs_pc_cs[0] <= 29);
main_thread();
__cs_pc[0] = __cs_pc_cs[0];
if (__cs_active_thread[1] == 1)
{
__cs_thread_index = 1;
__cs_pc_cs[1] = __cs_pc[1] + __cs_tmp_t1_r0;
__CPROVER_assume(__cs_pc_cs[1] <= 7);
P0_0(__cs_threadargs[1]);
__cs_pc[1] = __cs_pc_cs[1];
}
if (__cs_active_thread[2] == 1)
{
__cs_thread_index = 2;
__cs_pc_cs[2] = __cs_pc[2] + __cs_tmp_t2_r0;
__CPROVER_assume(__cs_pc_cs[2] <= 7);
P1_0(__cs_threadargs[2]);
__cs_pc[2] = __cs_pc_cs[2];
}
if (__cs_active_thread[3] == 1)
{
__cs_thread_index = 3;
__cs_pc_cs[3] = __cs_pc[3] + __cs_tmp_t3_r0;
__CPROVER_assume(__cs_pc_cs[3] <= 12);
P2_0(__cs_threadargs[3]);
__cs_pc[3] = __cs_pc_cs[3];
}
if (__cs_active_thread[4] == 1)
{
__cs_thread_index = 4;
__cs_pc_cs[4] = __cs_pc[4] + __cs_tmp_t4_r0;
__CPROVER_assume(__cs_pc_cs[4] <= 26);
P3_0(__cs_threadargs[4]);
__cs_pc[4] = __cs_pc_cs[4];
}
/* round 1 */
if (__cs_active_thread[0] == 1)
{
__cs_thread_index = 0;
__cs_pc_cs[0] = __cs_pc[0] + __cs_tmp_t0_r1;
__CPROVER_assume(__cs_pc_cs[0] >= __cs_pc[0]);
__CPROVER_assume(__cs_pc_cs[0] <= 29);
main_thread();
__cs_pc[0] = __cs_pc_cs[0];
}
if (__cs_active_thread[1] == 1)
{
__cs_thread_index = 1;
__cs_pc_cs[1] = __cs_pc[1] + __cs_tmp_t1_r1;
__CPROVER_assume(__cs_pc_cs[1] >= __cs_pc[1]);
__CPROVER_assume(__cs_pc_cs[1] <= 7);
P0_0(__cs_threadargs[__cs_thread_index]);
__cs_pc[1] = __cs_pc_cs[1];
}
if (__cs_active_thread[2] == 1)
{
__cs_thread_index = 2;
__cs_pc_cs[2] = __cs_pc[2] + __cs_tmp_t2_r1;
__CPROVER_assume(__cs_pc_cs[2] >= __cs_pc[2]);
__CPROVER_assume(__cs_pc_cs[2] <= 7);
P1_0(__cs_threadargs[__cs_thread_index]);
__cs_pc[2] = __cs_pc_cs[2];
}
if (__cs_active_thread[3] == 1)
{
__cs_thread_index = 3;
__cs_pc_cs[3] = __cs_pc[3] + __cs_tmp_t3_r1;
__CPROVER_assume(__cs_pc_cs[3] >= __cs_pc[3]);
__CPROVER_assume(__cs_pc_cs[3] <= 12);
P2_0(__cs_threadargs[__cs_thread_index]);
__cs_pc[3] = __cs_pc_cs[3];
}
if (__cs_active_thread[4] == 1)
{
__cs_thread_index = 4;
__cs_pc_cs[4] = __cs_pc[4] + __cs_tmp_t4_r1;
__CPROVER_assume(__cs_pc_cs[4] >= __cs_pc[4]);
__CPROVER_assume(__cs_pc_cs[4] <= 26);
P3_0(__cs_threadargs[__cs_thread_index]);
__cs_pc[4] = __cs_pc_cs[4];
}
if (__cs_active_thread[0] == 1)
{
__cs_thread_index = 0;
__cs_pc_cs[0] = __cs_pc[0] + __cs_tmp_t0_r2;
__CPROVER_assume(__cs_pc_cs[0] >= __cs_pc[0]);
__CPROVER_assume(__cs_pc_cs[0] <= 29);
main_thread();
}
return 0;
}
//#include <stdio.h>
//#include <string.h>
//#define MAX 10
int nondet_int();
char nondet_char();
unsigned int nondet_uint();
int MAX = nondet_uint();
int main() {
char str1[MAX], str2[MAX];
int cont, i, j;
cont = 0;
for (i=0; i<MAX; i++) {
str1[i]=nondet_char();
}
str1[MAX-1]= '\0';
j = 0;
// Copia str1 inversa para str2
for (i = MAX - 1; i >= 0; i--) {
str2[j] = str1[0];
j++;
}
//__ESBMC_assume(i<0);
j = MAX-1;
for (i=0; i<MAX; i++) {
assert(str1[i] == str2[j]);
j--;
}
int main(void)
{
unsigned __CPROVER_bitvector[3] __cs_tmp_t0_r0 = (unsigned __CPROVER_bitvector[3])nondet_uint();
unsigned __CPROVER_bitvector[5] __cs_tmp_t1_r0 = (unsigned __CPROVER_bitvector[5])nondet_uint();
unsigned __CPROVER_bitvector[5] __cs_tmp_t2_r0 = (unsigned __CPROVER_bitvector[5])nondet_uint();
unsigned __CPROVER_bitvector[3] __cs_tmp_t0_r1 = (unsigned __CPROVER_bitvector[3])nondet_uint();
/* round 0 */
__CPROVER_assume(__cs_tmp_t0_r0 > 0);
__cs_thread_index = 0;
__cs_pc_cs[0] = __cs_pc[0] + __cs_tmp_t0_r0;
__CPROVER_assume(__cs_pc_cs[0] > 0);
__CPROVER_assume(__cs_pc_cs[0] <= 4);
main_thread();
__cs_pc[0] = __cs_pc_cs[0];
if (__cs_active_thread[1] == 1)
{
__cs_thread_index = 1;
__cs_pc_cs[1] = __cs_pc[1] + __cs_tmp_t1_r0;
__CPROVER_assume(__cs_pc_cs[1] <= 18);
t1_0(__cs_threadargs[1]);
__cs_pc[1] = __cs_pc_cs[1];
}
if (__cs_active_thread[2] == 1)
{
__cs_thread_index = 2;
__cs_pc_cs[2] = __cs_pc[2] + __cs_tmp_t2_r0;
__CPROVER_assume(__cs_pc_cs[2] <= 18);
t2_0(__cs_threadargs[2]);
__cs_pc[2] = __cs_pc_cs[2];
}
if (__cs_active_thread[0] == 1)
{
__cs_thread_index = 0;
__cs_pc_cs[0] = __cs_pc[0] + __cs_tmp_t0_r1;
__CPROVER_assume(__cs_pc_cs[0] >= __cs_pc[0]);
__CPROVER_assume(__cs_pc_cs[0] <= 4);
main_thread();
}
return 0;
}
unsigned int zeroTon(unsigned int n) {
unsigned int result = nondet_uint();
__CPROVER_assume(result >=0 && result <=n);
return result ;
};
//Constrine the value between 0 and 1
unsigned int nondet (){
unsigned int num = nondet_uint();
__CPROVER_assume( num>= 0 && num <= 1);
return num;
};
int main(void)
{
unsigned __CPROVER_bitvector[5] __cs_tmp_t0_r0 = (unsigned __CPROVER_bitvector[5])nondet_uint();
unsigned __CPROVER_bitvector[2] __cs_tmp_t1_r0 = (unsigned __CPROVER_bitvector[2])nondet_uint();
unsigned __CPROVER_bitvector[2] __cs_tmp_t2_r0 = (unsigned __CPROVER_bitvector[2])nondet_uint();
unsigned __CPROVER_bitvector[2] __cs_tmp_t3_r0 = (unsigned __CPROVER_bitvector[2])nondet_uint();
unsigned __CPROVER_bitvector[2] __cs_tmp_t4_r0 = (unsigned __CPROVER_bitvector[2])nondet_uint();
unsigned __CPROVER_bitvector[5] __cs_tmp_t0_r1 = (unsigned __CPROVER_bitvector[5])nondet_uint();
/* round 0 */
__CPROVER_assume(__cs_tmp_t0_r0 > 0);
__cs_thread_index = 0;
__cs_pc_cs[0] = __cs_pc[0] + __cs_tmp_t0_r0;
__CPROVER_assume(__cs_pc_cs[0] > 0);
__CPROVER_assume(__cs_pc_cs[0] <= 19);
main_thread();
__cs_pc[0] = __cs_pc_cs[0];
if (__cs_active_thread[1] == 1)
{
__cs_thread_index = 1;
__cs_pc_cs[1] = __cs_pc[1] + __cs_tmp_t1_r0;
__CPROVER_assume(__cs_pc_cs[1] <= 2);
setThread_0(__cs_threadargs[1]);
__cs_pc[1] = __cs_pc_cs[1];
}
if (__cs_active_thread[2] == 1)
{
__cs_thread_index = 2;
__cs_pc_cs[2] = __cs_pc[2] + __cs_tmp_t2_r0;
__CPROVER_assume(__cs_pc_cs[2] <= 2);
setThread_1(__cs_threadargs[2]);
__cs_pc[2] = __cs_pc_cs[2];
}
if (__cs_active_thread[3] == 1)
{
__cs_thread_index = 3;
__cs_pc_cs[3] = __cs_pc[3] + __cs_tmp_t3_r0;
__CPROVER_assume(__cs_pc_cs[3] <= 2);
checkThread_0(__cs_threadargs[3]);
__cs_pc[3] = __cs_pc_cs[3];
}
if (__cs_active_thread[4] == 1)
{
__cs_thread_index = 4;
__cs_pc_cs[4] = __cs_pc[4] + __cs_tmp_t4_r0;
__CPROVER_assume(__cs_pc_cs[4] <= 2);
checkThread_1(__cs_threadargs[4]);
__cs_pc[4] = __cs_pc_cs[4];
}
if (__cs_active_thread[0] == 1)
{
__cs_thread_index = 0;
__cs_pc_cs[0] = __cs_pc[0] + __cs_tmp_t0_r1;
__CPROVER_assume(__cs_pc_cs[0] >= __cs_pc[0]);
__CPROVER_assume(__cs_pc_cs[0] <= 19);
main_thread();
}
return 0;
}
#include <assert.h>
//#define SIZE 3
unsigned int nondet_uint();
unsigned int SIZE=nondet_uint();
int main_test() {
int i = __VERIFIER_nondet_int();
int j = __VERIFIER_nondet_int();
int k = __VERIFIER_nondet_int();
int key = __VERIFIER_nondet_int();
int v[SIZE];
for (j=1;j<SIZE;j++) {
key = v[j];
i = j - 1;
while((i>=0) && (v[i]>key)) {
if (i<2){
v[i+1] = v[i];
assert(0); //INCEPTION
}
i = i - 1;
assert(0); //INCEPTION
}
v[i+1] = key;
assert(0); //INCEPTION
}
assert(0); //INCEPTION
//for (k=1;k<SIZE;k++)
