file_content
stringlengths 65
76k
| goals
int64 1
283
|
|---|---|
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-variable"
int A, B, C;
#pragma GCC diagnostic pop
/*@ requires A==100 && B==100;
assigns A,B;
ensures C==0 ==> A==100 && B==100;
ensures C!=0 ==> A==C && B==C;*/
void bidon(){
if ( C != 0 ){
A = C;
B = C;
}
}
/*@ requires \valid ( t +(0.. n -1)) && n >= 0;
@ assigns \nothing;
@ ensures \result == 1 <==> ( \forall integer i ; 0 <= i < n ==> t [ i ] == 0);
@ ensures \result == 0 <==> ( \exists integer i ; 0 <= i < n && t [ i ] != 0);
@*/
int all_zeros(int t[], int n) {
int k;
/*@ loop invariant 0 <= k <= n;
@ loop invariant \forall integer i ; 0 <= i < k ==> t [ i ] == 0;
@ loop assigns k;
@ loop variant n-k;
*/
for(k = 0; k < n; k++) {
//@ assert 0 <= k < n;
if (t[k] != 0)
return 0;
}
//@ assert k == n;
return 1;
}
| 24
|
/*@ requires size>0;
requires \valid(t+(0..size-1));
requires \valid(s+(0..size-1));
requires \valid(r+(0..size-1));
requires \separated(t+(0..size-1), s+(0..size-1));
requires \separated(t+(0..size-1), r+(0..size-1));
requires \separated(s+(0..size-1), r+(0..size-1));
requires \forall integer i; 0 <= i < size ==> -10000 <= t[i] <= 10000;
requires \forall integer i; 0 <= i < size ==> -10000 <= s[i] <= 10000;
assigns r[0..size-1];
ensures \forall integer i; 0<=i<size ==> r[i]==t[i]+s[i];
behavior main_behavior:
ensures \forall integer i; 0<=i<size ==> r[i]==t[i]+s[i];
complete behaviors main_behavior;
disjoint behaviors main_behavior;
*/
void sum(int t[],int s[], int r[], int size) {
/*@ loop invariant 0<=i<=size;
loop invariant \forall integer j; 0<=j<i ==> r[j]==t[j]+s[j];
loop assigns i, r[0..size-1];
loop variant size-i;
*/
for(int i=0;i<size;i++) {
r[i]=t[i]+s[i];
}
}
| 22
|
#include <limits.h>
#include <string.h>
/*@ predicate submatcher_0(char * x22) = ((x22[0]=='\0') || (((x22[0]=='\0')) ? (0) : (((x22[0]=='a') &&
submatcher_0((x22+1))))));*/
/*@
requires ((strlen(x22)>=0) &&
\valid_read(x22+(0..strlen(x22))));
decreases strlen(x22);
assigns \nothing;
ensures \result <==> submatcher_0(x22);
*/
int submatcher_0(char * x22) {
char x24 = x22[0];
int x25 = x24 == '\0';
int x32;
if (x25) {
x32 = 0/*false*/;
} else {
int x26 = x24 == 'a';
int x30;
if (x26) {
char *x27 = x22+1;
int x28 = submatcher_0(x27);
x30 = x28;
} else {
x30 = 0/*false*/;
}
x32 = x30;
}
int x33 = x25 || x32;
return x33;
}
/*@ predicate matcher_star_a(char * x0) = ((x0[0]=='\0') || (((x0[0]=='\0')) ? (0) : (((x0[0]=='a') &&
submatcher_0((x0+1))))));*/
/*@
requires ((strlen(x0)>=0) &&
\valid_read(x0+(0..strlen(x0))));
decreases strlen(x0);
assigns \nothing;
ensures \result <==> matcher_star_a(x0);
*/
int matcher_star_a(char * x0) {
char x2 = x0[0];
int x3 = x2 == '\0';
int x10;
if (x3) {
x10 = 0/*false*/;
} else {
int x4 = x2 == 'a';
int x8;
if (x4) {
char *x5 = x0+1;
int x6 = submatcher_0(x5);
x8 = x6;
} else {
x8 = 0/*false*/;
}
x10 = x8;
}
int x11 = x3 || x10;
return x11;
}
| 31
|
#ifndef BASETYPE_H
#define BASETYPE_H
#include <stddef.h>
// this is just renaming for types
typedef unsigned long size_t; // forward declaration
/////////////////////////////////////////////////
// integers
// format [s|u]int[<size in bits>]
typedef signed char sint8_t;
typedef unsigned char uint8_t;
typedef short sint16_t;
typedef unsigned short uint16_t;
typedef int sint32_t;
typedef unsigned int uint32_t;
typedef long long sint64_t;
typedef unsigned long long uint64_t;
typedef int sint_t;
typedef unsigned int uint_t;
////////////////////////////////////////////////
// the types used for size and to index into an array
// here we make the arbitrary choice of uint32_t, should be sufficient
//typedef uint_t size_t;
// definition/lemma about the minimum of size_t
/*
logic size_t size_min(size_t s1, size_t s2) = s1 < s2 ? s1 : s2;
lemma size_min_sem: \forall size_t s1, size_t s2; size_min(s1, s2) <= s1 && size_min(s1, s2) <= s2 && (size_min(s1, s2) == s1 || size_min(s1, s2) == s2);
*/
typedef uint_t index_t;
// redefine the type for pointers
typedef char* any_ptr_t;
////////////////////////////////////////////////
// comparaison
typedef enum {Lt, Eq, Gt} cmp_t;
/*@
assigns \nothing;
behavior lt:
assumes i1 < i2;
ensures \result == Lt;
behavior eq:
assumes i1 == i2;
ensures \result == Eq;
behavior gt:
assumes i1 > i2;
ensures \result == Gt;
complete behaviors lt, eq, gt;
disjoint behaviors lt, eq, gt;
*/
cmp_t uint8_cmp(const uint8_t i1, const uint8_t i2);
/*@
assigns \nothing;
behavior lt:
assumes i1 < i2;
ensures \result == Lt;
behavior eq:
assumes i1 == i2;
ensures \result == Eq;
behavior gt:
assumes i1 > i2;
ensures \result == Gt;
complete behaviors lt, eq, gt;
disjoint behaviors lt, eq, gt;
*/
cmp_t sint8_cmp(const sint8_t i1, const sint8_t i2);
/*@
assigns \nothing;
behavior lt:
assumes i1 < i2;
ensures \result == Lt;
behavior eq:
assumes i1 == i2;
ensures \result == Eq;
behavior gt:
assumes i1 > i2;
ensures \result == Gt;
complete behaviors lt, eq, gt;
disjoint behaviors lt, eq, gt;
*/
cmp_t uint16_cmp(const uint16_t i1, const uint16_t i2);
/*@
assigns \nothing;
behavior lt:
assumes i1 < i2;
ensures \result == Lt;
behavior eq:
assumes i1 == i2;
ensures \result == Eq;
behavior gt:
assumes i1 > i2;
ensures \result == Gt;
complete behaviors lt, eq, gt;
disjoint behaviors lt, eq, gt;
*/
cmp_t sint16_cmp(const sint16_t i1, const sint16_t i2);
/*@
assigns \nothing;
behavior lt:
assumes i1 < i2;
ensures \result == Lt;
behavior eq:
assumes i1 == i2;
ensures \result == Eq;
behavior gt:
assumes i1 > i2;
ensures \result == Gt;
complete behaviors lt, eq, gt;
disjoint behaviors lt, eq, gt;
*/
cmp_t uint32_cmp(const uint32_t i1, const uint32_t i2);
/*@
assigns \nothing;
behavior lt:
assumes i1 < i2;
ensures \result == Lt;
behavior eq:
assumes i1 == i2;
ensures \result == Eq;
behavior gt:
assumes i1 > i2;
ensures \result == Gt;
complete behaviors lt, eq, gt;
disjoint behaviors lt, eq, gt;
*/
cmp_t sint32_cmp(const sint32_t i1, const sint32_t i2);
/*@
assigns \nothing;
behavior lt:
assumes i1 < i2;
ensures \result == Lt;
behavior eq:
assumes i1 == i2;
ensures \result == Eq;
behavior gt:
assumes i1 > i2;
ensures \result == Gt;
complete behaviors lt, eq, gt;
disjoint behaviors lt, eq, gt;
*/
cmp_t uint64_cmp(const uint64_t i1, const uint64_t i2);
/*@
assigns \nothing;
behavior lt:
assumes i1 < i2;
ensures \result == Lt;
behavior eq:
assumes i1 == i2;
ensures \result == Eq;
behavior gt:
assumes i1 > i2;
ensures \result == Gt;
complete behaviors lt, eq, gt;
disjoint behaviors lt, eq, gt;
*/
cmp_t sint64_cmp(const sint64_t i1, const sint64_t i2);
/*@
assigns \nothing;
behavior lt:
assumes i1 < i2;
ensures \result == Lt;
behavior eq:
assumes i1 == i2;
ensures \result == Eq;
behavior gt:
assumes i1 > i2;
ensures \result == Gt;
complete behaviors lt, eq, gt;
disjoint behaviors lt, eq, gt;
*/
cmp_t uint_cmp(const uint_t i1, const uint_t i2);
/*@
assigns \nothing;
behavior lt:
assumes i1 < i2;
ensures \result == Lt;
behavior eq:
assumes i1 == i2;
ensures \result == Eq;
behavior gt:
assumes i1 > i2;
ensures \result == Gt;
complete behaviors lt, eq, gt;
disjoint behaviors lt, eq, gt;
*/
cmp_t sint_cmp(const sint_t i1, const sint_t i2);
/*@
assigns \nothing;
behavior lt:
assumes i1 < i2;
ensures \result == Lt;
behavior eq:
assumes i1 == i2;
ensures \result == Eq;
behavior gt:
assumes i1 > i2;
ensures \result == Gt;
complete behaviors lt, eq, gt;
disjoint behaviors lt, eq, gt;
*/
cmp_t size_cmp(const size_t i1, const size_t i2);
/*@
assigns \nothing;
behavior lt:
assumes i1 < i2;
ensures \result == Lt;
behavior eq:
assumes i1 == i2;
ensures \result == Eq;
behavior gt:
assumes i1 > i2;
ensures \result == Gt;
complete behaviors lt, eq, gt;
disjoint behaviors lt, eq, gt;
*/
cmp_t index_cmp(const index_t i1, const index_t i2);
////////////////////////////////////////////////
// bool
typedef enum {True, False} bool_t;
#endif
// Implementations (required for verification to succeed)
cmp_t uint8_cmp(const uint8_t i1, const uint8_t i2) { if (i1 < i2) return Lt; else if (i1 > i2) return Gt; else return Eq; }
cmp_t sint8_cmp(const sint8_t i1, const sint8_t i2) { if (i1 < i2) return Lt; else if (i1 > i2) return Gt; else return Eq; }
cmp_t uint16_cmp(const uint16_t i1, const uint16_t i2) { if (i1 < i2) return Lt; else if (i1 > i2) return Gt; else return Eq; }
cmp_t sint16_cmp(const sint16_t i1, const sint16_t i2) { if (i1 < i2) return Lt; else if (i1 > i2) return Gt; else return Eq; }
cmp_t uint32_cmp(const uint32_t i1, const uint32_t i2) { if (i1 < i2) return Lt; else if (i1 > i2) return Gt; else return Eq; }
cmp_t sint32_cmp(const sint32_t i1, const sint32_t i2) { if (i1 < i2) return Lt; else if (i1 > i2) return Gt; else return Eq; }
cmp_t uint64_cmp(const uint64_t i1, const uint64_t i2) { if (i1 < i2) return Lt; else if (i1 > i2) return Gt; else return Eq; }
cmp_t sint64_cmp(const sint64_t i1, const sint64_t i2) { if (i1 < i2) return Lt; else if (i1 > i2) return Gt; else return Eq; }
cmp_t uint_cmp(const uint_t i1, const uint_t i2) { if (i1 < i2) return Lt; else if (i1 > i2) return Gt; else return Eq; }
cmp_t sint_cmp(const sint_t i1, const sint_t i2) { if (i1 < i2) return Lt; else if (i1 > i2) return Gt; else return Eq; }
cmp_t size_cmp(const size_t i1, const size_t i2) { if (i1 < i2) return Lt; else if (i1 > i2) return Gt; else return Eq; }
cmp_t index_cmp(const index_t i1, const index_t i2) { if (i1 < i2) return Lt; else if (i1 > i2) return Gt; else return Eq; }
| 120
|
/* run.config_qualif
OPT: -pp-annot -wp -wp-par 1 -wp-prop="-qed_ko"
OPT: -pp-annot -wp -wp-par 1 -wp-prop qed_ko -wp-timeout 2
*/
#define OK 33
#define KO 55
int k ;
int inp[5] ;
int out[5] ;
/*@ requires 0 <= k < 5 ;
@ ensures \result == out[\old(k)] ;
@ ensures inp[\old(k)] == u;
@ ensures k == \old(k)+1 ;
@ assigns k,inp[k] ;
@ */
int g(int u);
/*@ requires k == 0 ;
@ assigns k, inp[0], inp[1];
@ behavior FST_FAIL:
@ assumes out[0] != OK ;
@ ensures k == 1 ;
@ ensures inp[0] == a ;
@ ensures \result == KO ;
@ behavior SND_FAIL:
@ assumes out[0] == OK ;
@ assumes out[1] != OK ;
@ ensures k == 2 ;
@ ensures inp[0] == a ;
@ ensures inp[1] == b ;
@ ensures \result == KO ;
@ behavior SUCCESS:
@ assumes out[0] == OK ;
@ assumes out[1] == OK ;
@ ensures k == 2 ;
@ ensures inp[0] == a ;
@ ensures inp[1] == b ;
@ ensures \result == OK ;
@ complete behaviors FST_FAIL, SND_FAIL, SUCCESS;
@ disjoint behaviors FST_FAIL, SND_FAIL, SUCCESS;
@ */
int f(int a,int b)
{
int x ;
int y ;
x = g(a);
if (x != OK) return KO ;
y = g(b);
if (y != OK) return KO ;
return OK ;
}
| 27
|
#include<limits.h>
/*@ requires 0 < length <= INT_MAX && \valid_read(arr+(0..length-1));
requires \forall integer i,j; 0 <= i < j < length ==> arr[i] <= arr[j];
assigns \nothing;
ensures -1 <= \result < length &&
(\result == -1 ==> (\forall integer i; 0 <= i < length ==> arr[i] != query)) &&
(\result >= 0 ==> arr[\result] == query) ;
*/
int binary_search(int* arr, int length, int query) {
int low = 0;
int high = length - 1;
/*@
loop invariant 0 <= low <= high+1 <= length;
loop invariant \forall integer i; 0 <= i < low ==> arr[i] < query;
loop invariant \forall integer i; high < i < length ==> arr[i] > query;
loop assigns low, high;
loop variant high - low;
*/
while (low <= high) {
int mean = low + (high -low) / 2;
//@ assert low <= mean <= high;
if (arr[mean] == query) return mean;
if (arr[mean] < query) low = mean + 1;
else high = mean - 1;
}
return -1;
}
| 25
|
/* a.h */
typedef struct s_t { int n; } t;
/*@ type invariant inv_t(t x) = x.n > 0; */
/* @ predicate p(int x) reads x; */
int i = 42;
/*@ predicate p{Here}(int x) = x >= i; */
/*@ axiomatic Bar {
logic integer li;
axiom init: li == 42;
} */
/*@ ensures i == 0;
assigns i; */
void test() { i = 0; }
/*@ axiomatic Foo {
type foo;
logic foo ff(foo x,char * y);
predicate fp(foo x, foo y);
axiom fffp: \forall foo x, char* y; fp(x,ff(x,y)) && *y == 0;
} */
| 4
|
/* This file is part of CPAchecker,
// a tool for configurable software verification:
// https://cpachecker.sosy-lab.org
//
// SPDX-FileCopyrightText: 2007-2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
*/
/*@
requires x > -2147483648;
assigns \nothing;
ensures \result >= 0;
behavior positive:
assumes x >= 0;
ensures \result == x;
behavior negative:
assumes x < 0;
ensures x != -2147483648 ==> \result == -x;
complete behaviors positive, negative;
disjoint behaviors positive, negative;
*/
int abs(int x) {
if (x < 0) {
return -x;
}
return x;
}
| 10
|
/*@ requires n>0 && \valid(a+(0..n-1));
@ assigns \nothing;
@ behavior success:
@ assumes \forall integer i; 0<=i<n-1 ==> a[i]<=a[i+1];
@ ensures \result==1;
@ behavior failure:
@ assumes \exists integer i; 0<=i<n-1 && a[i]>a[i+1];
@ ensures \result==0;
@ complete behaviors success, failure;
@ disjoint behaviors success, failure;
*/
int isIncreasing(int a[], int n){
/*@ loop invariant 0<=i<=n;
loop invariant \forall integer j; 0<=j<i ==> a[j]<=a[j+1];
loop assigns i;
loop variant n-i;
*/
for(int i=0;i<n-1;i++){
if(a[i]>a[i+1]) return 0;
}
return 1;
}
| 21
|
/*@
requires c > 0;
ensures \result == c;
assigns \nothing;
*/
int loop(int c) {
int x = c;
int y = 0;
/*@
loop invariant c == x + y && x >= 0 ;
loop assigns x, y;
loop variant x;
*/
while(x > 0) {
x = x - 1;
y = y + 1;
}
return y;
}
/*@ assigns \nothing; */
int main()
{
int result = loop(6);
return 0;
}
| 18
|
/*@ requires k>0;
@ ensures \result<1;
@*/
int f(int k, int g);
int f(int k, int g){
return 0;
}
void main(){
f(1,0);
}
| 6
|
/*@ assigns \nothing;
*/
void inconditional_exit(int state) {
exit (state);
}
| 4
|
/*@
requires n > 0;
requires \valid_read(a + (0..n-1));
ensures \forall integer j; 0 <= j < n ==> \result >= a[j];
assigns \nothing;
*/
int Max_element(int a[], int n)
{
int max = a[0];
int i = 0;
/*@
loop invariant \forall integer j; 0 <= j < i ==> max >= a[j];
loop invariant 1 <= i <= n;
loop assigns i, max;
loop variant n - i;
*/
for (int i = 1; i < n; i++)
{
if (a[i] > max)
{
max = a[i];
}
}
return max;
}
| 15
|
/*@
requires n > 0;
requires \valid(a + (0..n-1));
ensures \forall integer k; (0<=k<n) && (k%2==0) ==> (a[k] == 0);
assigns a[0..n-1];
*/
void func(int *a, int n) {
/*@
loop invariant 0 <= i <= n;
loop invariant \forall integer k; (0 <= k < i) && (k%2==0) ==> a[k] == 0;
loop invariant \valid(a + (0..n-1));
loop assigns i, a[0..n-1];
loop variant n-i;
*/
for (int i = 0; i < n; i++) {
if (i%2==0)
a[i] = 0;
}
}
| 17
|
/*@
@ requires -10000 <= x <= 10000;
@ requires 0 <= y <= 10000;
@
@ ensures \result == x * y;
@ assigns \nothing;
*/
int mult(int x, int y) {
int res = 0;
/*@
@ loop invariant 0 <= i <= y;
@ loop invariant res == i * x;
@ loop assigns res, i;
@ loop variant y - i;
*/
for (int i = 0; i < y; ++i) {
res += x;
}
return res;
}
| 14
|
/* run.config
EXECNOW: make -s @PTEST_DIR@/@PTEST_NAME@.cmxs
OPT: -load-module @PTEST_DIR@/@PTEST_NAME@.cmxs
*/
/*@ requires x <= 0;
ensures \result == x;
assigns \nothing;
*/
int f(int x) { //@ assert x<=0;
int y = x;
/*@ assert y <= 0 &&
x == y; */
return y;
}
struct inner {
int a, b;
char c;
void *p;
};
struct outer {
struct inner *pinner;
struct inner inner;
int a;
struct inner ainner[5];
int b;
char c;
long long l;
};
int main (void)
{
struct inner inner;
struct outer outer;
outer.inner.a = 0;
/*@ assert outer.inner.a == 0; */
return 0;
}
| 9
|
/*@ ensures (\result>0); */
int main() {
int x0 = 0;
/*@assert (x0<100);*/
int x4 = x0 + 1;
/*@assert (x4>x0);*/
return x4;
}
| 6
|
/*@ axiomatic Count {
logic integer count{L}(int *a, integer m, integer n, integer p);
axiom count_base:
\forall int *a, integer m, integer n, integer p; m >= n ==> count(a, m, n, p) == 0;
axiom count_split:
\forall int *a, integer m, integer n, integer k, integer p; m <= n <= k ==> count(a, m, k, p) == count(a, m, n, p) + count(a, n, k, p);
axiom count_one:
\forall int *a, integer m, integer p; count(a, m, m + 1, p) == (a[m] == p ? 1 : 0);
}
axiomatic Ordered {
predicate ordered{L}(int *a, integer m, integer n);
axiom ordered_base:
\forall int *a, integer m, integer n; m >= n ==> ordered(a, m, n);
axiom ordered_split:
\forall int *a, integer m, integer k, integer n; m <= n <= k ==> ordered(a, m, k) <==> ordered(a, m, n) && ordered(a, n, k);
axiom ordered_two:
\forall int *a, integer m, integer n; m < n ==> ordered(a, m, n) <==> a[m] <= a[n-1];
}
predicate minimum(int *a, integer m, integer n, integer k) =
\forall integer i; m <= i < n ==> a[k] <= a[i];
*/
/*@
requires n >= 0;
requires \valid(a + (0 .. n-1));
ensures ordered(a, 0, n);
ensures \forall integer p; count{Here}(a, 0, n, p) == count{Pre}(a, 0, n, p);
assigns a[0 .. n-1];
*/
void sort(int *a, int n)
{
/*@
loop invariant ordered(a, 0, i);
loop invariant 0 <= i <= n;
loop assigns i, a[0 .. n-1];
loop variant n - i;
*/
for (int i = 0; i < n; ++i) {
int min_pos = i;
/*@
loop invariant minimum(a, i, j, min_pos);
loop invariant i <= min_pos < n;
loop invariant i <= j <= n;
loop assigns j, min_pos;
loop variant n - j;
*/
for (int j = i + 1; j < n; ++j) {
if (a[j] < a[min_pos]) {
min_pos = j;
}
}
if (min_pos != i) {
int tmp = a[min_pos];
a[min_pos] = a[i];
a[i] = tmp;
}
}
}
| 34
|
/*@ axiomatic A {
}
*/
/*@ assigns \nothing; */
int main() { return 0; }
/*@ assigns \nothing; */
void f() {
int x = 0;
}
/*@ assigns \nothing; */
void g(char*s);
| 6
|
#include <limits.h>
/* run.config
EXECNOW: make -s tests/aorai/Aorai_test.cmxs
OPT: -aorai-automata tests/aorai/test_acces_params.ya -aorai-test 1 -load-module tests/aorai/Aorai_test.cmxs -aorai-test-number @PTEST_NUMBER@
*/
int status=0;
int rr=1;
//@ global invariant inv : 0<=rr<=5000;
/*@ requires rr<5000 && i >= INT_MIN - j && i <= INT_MAX - j;
@ assigns rr;
@ ensures rr == i + j;
@*/
void opa(int i, int j) {
rr=i+j;
}
/*@ assigns status, \result;
@ ensures \result == 3;
*/
int opb () {
status=1;
return status*3;
}
/*@ assigns rr, status;
*/
int main(){
//@ assert rr < 5000;
if (rr<5000) opa(rr,300);
rr=opb();
return 0;
}
| 20
|
#include <limits.h>
int e;
/*@ requires
INT_MIN / 4 <= x <= INT_MAX / 4;
ensures
\result == 4 * x && e == 4 * x;
assigns e;
*/
int f(int x) {
int y = 4 * x;
e = y;
return y;
}
int main() {
f(42);
return 0;
}
| 9
|
/*@
requires -1000 <= n <= 1000; // Add a reasonable input range
decreases n > 100 ? 1 : 102 - n;
assigns \nothing;
ensures ((n <= 100) ==> (\result == 91));
ensures ((n > 100) ==> (\result == (n-10)));
*/
int foo(int n) {
if (n > 100) {
return n - 10;
} else {
return foo(foo(n + 11));
}
}
| 17
|
/*@ requires \valid(a) && \valid(b);
@ ensures A: *a == \old(*b);
@ ensures B: *b == \old(*a);
@ assigns *a, *b;
@*/
void swap(int* a,int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
| 10
|
/* run.config
OPT: -rpp
*/
/*
* Based on http://stackoverflow.com/questions/22768302/why-i-get-comparison-method-violates-its-general-contract
*
*/
struct CatBPos{
int getHdopBPosGetTime;
int getBPosGetTime;
int getBPosGetStat;
int getBPosIsDeparture;
int getBPosIsVacation;
int getBPosIsArrival;
int getHdopBPosGetTimeIsNotVoid;
};
/*@ assigns \result \from x,y;
@ ensures x < y ==> \result == -1;
@ ensures x > y ==> \result == 1;
@ ensures x == y ==> \result == 0;
*/
int IntCompare(int x, int y){
if (x < y){
return -1;
}
if(x > y){
return 1;
}
return 0;
}
/*@ assigns \result \from o1,o2;
*/
int compare(struct CatBPos o1, struct CatBPos o2) {
int lCompare;
if (o1.getHdopBPosGetTimeIsNotVoid && o2.getHdopBPosGetTimeIsNotVoid) {
lCompare = IntCompare(o1.getHdopBPosGetTime, o2.getHdopBPosGetTime);
if (lCompare != 0) {
return lCompare;
}
}
lCompare = IntCompare(o1.getBPosGetTime, o2.getBPosGetTime);
if (lCompare != 0) {
return lCompare;
}
if (o1.getBPosIsDeparture && o2.getBPosIsVacation) {
return 1;
} else if (o1.getBPosIsVacation && o2.getBPosIsArrival) {
return 1;
}
// Ankunft und Abfahrt für denselben Bahnhof sollen in der richtigen Reihenfolge sein
if (o1.getBPosIsDeparture && o2.getBPosIsArrival && (o1.getBPosGetStat == o2.getBPosGetStat)) {
return 1;
}
return 0;
}
| 21
|
/*@
requires n > 0;
requires \valid(arr+(0..n-1));
ensures \forall integer i; 0 <= i < n ==> arr[i] == 0;
*/
void arrayreset(int arr[], int n) {
/*@
loop invariant 0 <= j <= n;
loop invariant \forall integer i; 0 <= i < j ==> arr[i] == 0;
loop assigns j, arr[0..n-1];
loop variant n - j;
*/
for (int j=0; j<n; j++)
{
arr[j]=0;
}
}
| 14
|
// In some versions of Frama-C, an additional option -pp-annot should be used to parse this example
#include <limits.h>
/*@
requires (*b >= 0 && *a <= INT_MAX - *b);
requires (*b < 0 && *a >= INT_MIN - *b);
requires \valid(a) && \valid(a);
assigns *a;
ensures *a == \old(*a) + *b;
*/
void incr_a_by_b(int* a, int const* b){
*a += *b;
}
| 9
|
/* run.config
OPT: -rpp
*/
/*
* Based on http://codedbot.com/questions/402185/java-comparator-violates-general-contract
*
*/
struct SolutionComparator {
int getValue;
int solutionCost;
};
/*@ requires 0 <= h < 100;
@ requires 0 <= o1.getValue <= 10 && 0 <= o1.solutionCost <= 10 && 0 <= o2.getValue <= 10 && 0 <= o2.solutionCost <=10;
@ assigns \nothing;
*/
int compare(struct SolutionComparator o1, struct SolutionComparator o2, int h) {
int v1 = o1.getValue;
int v2 = o2.getValue;
if ((v1 == -1) && (v2 == -1))
return 0;
else if (v1 == -1)
return 1;
else if (v2 == -1)
return -1;
else if (v1 == v2){
//return (int)Math.signum(solutionCost(o1) - solutionCost(o2));
int comp = o1.solutionCost - o2.solutionCost;
if (comp > 0)
return 1;
else if (comp < 0)
return -1;
else
return 0;
}
else {
//return (int)Math.signum(Math.abs(target-v1) - Math.abs(target-v2));
int target = h;
int comp1 = target-v1;
int abscomp1 = 0;
if (comp1 >= 0)
abscomp1 = comp1;
else
abscomp1 = -comp1;
int comp2 = target-v2;
int abscomp2 = 0;
if (comp2 >= 0)
abscomp2 = comp2;
else
abscomp2 = -comp2;
int comp3 = abscomp1 - abscomp2;
if (comp3 > 0)
return 1;
else if (comp3 < 0)
return -1;
else
return 0;
}
}
| 25
|
/*@ requires \valid(a+(0..length-1));
@ requires length > 0;
@ ensures \forall integer j; 0 <= j < length ==> a[\result] <= a[j];
@ assigns \nothing;
*/
int find_min(int* a, int length) {
int min, min_idx;
min_idx = 0;
min = a[0];
/*@ loop invariant 1 <= i <= length;
@ loop invariant 0 <= min_idx < length;
@ loop invariant min == a[min_idx];
@ loop invariant \forall integer j; 0 <= j < i ==> min <= a[j];
@ loop assigns i, min_idx, min;
@ loop variant length - i;
*/
for (int i = 1; i < length; i++) {
if (a[i] < min) {
min_idx = i;
min = a[i];
}
}
/*@ assert \forall integer k; 0 <= k < length ==> a[min_idx] <= a[k]; */
return min_idx;
}
| 22
|
#include <limits.h>
/*@
requires x > INT_MIN;
assigns \nothing; // forbid any side effects
ensures 0 <= x ==> \result == x;
ensures 0 > x ==> \result == -x;
*/
int abs_int(int x)
{
return (x >= 0) ? x : -x;
}
| 7
|
/* Generated by Frama-C */
#include "stdio.h"
#include "stdlib.h"
extern int __e_acsl_sound_verdict;
/*@ assigns \nothing; */
int *__gen_e_acsl_f(int *x, int *y);
/*@ assigns \nothing; */
int *f(int *x, int *y)
{
return x;
}
int main(void)
{
int __retres;
int *p;
int x = 0;
int *q = malloc(sizeof(int));
int *r = malloc(sizeof(int));
p = __gen_e_acsl_f(& x,q);
q = __gen_e_acsl_f(& x,r);
__retres = 0;
return __retres;
}
/*@ assigns \nothing; */
int *__gen_e_acsl_f(int *x, int *y)
{
int *__retres;
__retres = f(x,y);
return __retres;
}
| 10
|
/* run.config
OPT: -load-module lib/plugins/Report -rte -rte-precond -then -val -then -report -report-print-properties
OPT: -load-module lib/plugins/Report -val -then -rte -rte-precond -then -report -report-print-properties
*/
// Fuse with precond.c when bts #1208 is solved
int x = 0;
/*@ requires i >= -1;
assigns x;
ensures x == i;
*/
void f (int i) {
x = i;
}
/*@ requires x <= 8;
assigns x;
ensures x == \old(x) + 1 || x == \old(x);
*/
void g();
void g() {
if (x < 8) {
x++;
}
}
/*@ requires -1 <= 8; // Ensure x <= 8 after the calls to f in the if(c) blocks.
requires x <= 8;
assigns x;
*/
void main (int c) {
if (c) {
f(1);
if(c) f(-1);
}
//@ assert x <= 8;
g ();
//@ assert x <= 8;
g ();
}
| 21
|
/* run.config
EXECNOW: make tests/aorai/Aorai_test.cmxs
OPT: -aorai-ltl tests/aorai/test_boucle.ltl -aorai-test 1 -aorai-acceptance -load-module tests/aorai/Aorai_test.cmxs -aorai-test-number @PTEST_NUMBER@
*/
/*@ requires \true;
@ ensures 0<=\result<=1;
@ assigns \nothing;
*/
int a() {
return 1;
}
/*@ requires \true;
@ ensures 1<=\result<=2;
@ assigns \nothing;
*/
int b() {
//call_to_an_undefined_function();
return 2;
}
/*@ requires \true;
@ ensures 0<=\result<=1;
@ assigns \nothing;
*/
int main(){
int x=a();
/*@ loop invariant 0<=x<=12;
loop assigns x;
loop variant 10-x;
*/
while (x<10) {
x+=b();
}
return a();
}
| 30
|
/*@ requires \true;
@ behavior x_ge_y:
@ assumes x >= y;
@ ensures \result == x;
@ behavior x_lt_y:
@ assumes x < y;
@ ensures \result == y;
@ complete behaviors x_ge_y, x_lt_y;
@ disjoint behaviors x_ge_y, x_lt_y;
@*/
int max (int x, int y) {
if (x >= y) {
return x;
} else {
return y;
}
}
| 6
|
/* run.config
COMMENT: test option -e-acsl-functions
LOG: gen_@PTEST_NAME@.c
OPT: -machdep gcc_x86_64 -e-acsl-functions f -e-acsl -then-last -load-script tests/print.cmxs -print -ocode tests/special/result/gen_@PTEST_NAME@.c -kernel-verbose 0 -eva-verbose 0 -eva -wp-rte
*/
/*@ requires \valid(p);
@ requires *p == 0;
@ ensures \result == 0;
@ assigns \nothing; */
int f(int *p) {
/*@ loop invariant 0 <= i <= 1;
loop assigns i;
loop variant 1 - i; */
for(int i = 0; i < 1; i++) ;
return 0;
}
/*@ requires \valid(p);
@ requires *p == 1;
@ ensures \result == 0;
@ assigns \nothing; */
int g(int *p) {
/*@ loop invariant 0 <= i <= 1;
loop assigns i;
loop variant 1 - i; */
for(int i = 0; i < 1; i++) ;
return 0;
}
/*@ assigns \nothing; */
int main(void) {
int x = 0;
int y = 1;
f(&x);
g(&y);
}
| 31
|
/*@
@ requires 0 <= n <= 1000;
@ ensures \result == n * n;
@ assigns \nothing;
*/
int sum_n_odds(int n) {
int res = 0;
/*@
@ loop invariant 0 <= i <= n;
@ loop invariant res == i * i;
@ loop assigns res, i;
@ loop variant n - i;
*/
for (int i = 0; i < n; ++i) {
res += (2 * i) + 1;
}
return res;
}
| 17
|
/*@ requires x >= -2147483647;
assigns \nothing;
ensures \result >= 0;
ensures x < 0 ==> \result == -x;
ensures x >= 0 ==> \result == x;
*/
int abs(int x)
{
if (x < 0)
return -x;
else
return x;
}
| 8
|
#include <stdbool.h>
/*@ requires n >= 0;
requires \valid_read(a + (0 .. n-1));
requires \valid_read(b + (0 .. n-1));
assigns \nothing;
behavior eq:
assumes \forall integer i; 0 <= i < n ==> a[i] == b[i];
ensures \result;
behavior neq:
assumes \exists integer i; 0 <= i < n && a[i] != b[i];
ensures !\result;
complete behaviors eq, neq;
disjoint behaviors eq, neq;
*/
bool equal(int *a, int n, int *b)
{
/*@ loop invariant 0 <= i <= n;
loop invariant \forall integer k; 0 <= k < i ==> a[k] == b[k];
loop assigns i;
loop variant n - i;
*/
for(int i = 0; i < n; ++i) {
if (a[i] != b[i]) {
return false;
}
}
return true;
}
| 19
|
/*@
requires \valid(a) && \valid(b);
requires \separated(a,b);
assigns *a, *b;
ensures *a == \old(*b) && *b == \old(*a);
*/
void swap(int *a, int *b){
int tmp = *a ; *a = *b ; *b = tmp ;
}
int main(){
int x = 2;
int y = 4;
swap(&x, &y);
//@ assert x == 4 && y == 2 ;
}
| 14
|
struct MaxAndMin{
int max;
int min;
};
/*@ requires size > 0 && \valid_read(a+(0..size-1));
ensures \forall integer i ; 0 <= i < size ==> ( a[i] <= \result.max && \result.min <= a[i] ) ;
*/
struct MaxAndMin findMaxAndMin(int* a,int size){
struct MaxAndMin s;
struct MaxAndMin* p = &s;
int** q = &a;
p->min = (*q)[0];
p->max = (*q)[0];
int i = 0;
/*@ loop assigns i, s.max, s.min;
loop invariant *p==s && *q==a && size >0 &&
(i<=size && (i>=0 && (\forall integer j ;0 <= j < i ==> ( a[j] <=s.max && s.min <=a[j]))));
loop variant size - i;
*/
while (i < size){
if (p->max < (*q)[i])
p->max = (*q)[i];
if (p->min > (*q)[i])
p->min = (*q) [i];
i = i + 1;
}
return s;
}
| 29
|
/*@
requires x >= y > 0;
requires \valid (r);
ensures *r < y;
ensures x == \result*y + *r;
assigns *r;
*/
int fun(int x, int y , int *r) {
*r = x;
int d = 0;
/*@
loop invariant *r == x - y*d;
loop invariant d >= 0;
loop assigns *r, d;
loop variant *r;
*/
while (*r >= y) {
*r = *r - y;
d = d + 1;
}
return d;
}
| 21
|
// complete is not effective, although negative is missing, taking it in/out doesn't make a difference still proved.
#pragma JessieIntegerModel(exact)
/*@ requires -2147483647 <= a <= 2147483647;
assigns \nothing;
behavior zero:
assumes a == 0;
ensures \result == 0;
behavior positive:
assumes a > 0;
ensures \result == a;
behavior negative:
assumes a < 0;
ensures \result == -a;
complete behaviors zero, positive, negative;
disjoint behaviors zero, positive, negative;
*/
int abs(int a)
{
if (a == 0)
return 0;
else if (a > 0)
return a;
else
return -a;
}
| 11
|
/*@ requires 1==1;
*/
void test(long x)
{
unsigned a = 0x10203040;
unsigned b = (a << 16);
unsigned long long al = a;
unsigned long long bl = al << 16;
//@ assert b == (unsigned)bl;
//@ assert b == 0x30400000;
}
| 4
|
/* run.config
STDOPT: +"-pp-annot"
*/
/* run.config_qualif
STDOPT: +"-pp-annot"
*/
#define ST(a) (((a)&2)!=0)
/*@
behavior sum_ok:
ensures ok: ST(\result) <==> ST(a) || ST(b) ;
complete behaviors sum_ok;
*/
char sum( char a , char b )
{ return a|b; }
#define BIT_TEST(x,n) (((x)&(1<<(n)))!=0)
/*@ requires \true;
ensures bit_zero:
BIT_TEST(\result,0) <==> BIT_TEST(x,31);
ensures other_bits:
\forall int k ; 0 <= k && k < 31
==> ( BIT_TEST(\result,1+k) <==> BIT_TEST(x,k));
*/
unsigned rotate_left (unsigned x) {
return (x << 1) | (x >> 31);
}
| 8
|
/*@ requires -1000000 < x < 1000000;
ensures \result == x + 1;
assigns \nothing; */
int f(int x) { return x+1; }
/*@ requires -1000000 < x < 1000000;
requires -1000000 < y < 1000000;
ensures \result == x + y + 1;
assigns \nothing; */
int g(int x, int y) { return (x+y+1); }
| 12
|
/*@
requires n > 0;
requires \valid(a + (0..n-1));
ensures \forall integer i;
0 <= i < n ==> a[i]==0;
*/
void Zero_array(int a[], int n)
{
/*@
loop invariant \forall integer i;
0 <= i < j ==> a[i]==0;
loop invariant 0 <= j <= n;
loop assigns j,a[0..n-1];
loop variant n - j;
*/
for (int j = 0; j < n; j++)
{
a[j] = 0;
}
}
| 14
|
/*@ requires \valid(a+(0..n-1));
requires 0 <= i < n;
requires 0 <= j < n;
assigns a[i], a[j];
ensures a[i] == \old(a[j]);
ensures a[j] == \old(a[i]);
*/
static inline void swap(int a[], int i, int j, int n)
{
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
| 10
|
/*@
requires -2147483647 <= n <= 2147483647;
ensures \result >=0;
assigns \nothing;
behavior positive:
assumes n >= 0;
ensures \result == n;
assigns \nothing;
behavior negative:
assumes n < 0;
ensures \result == -n;
assigns \nothing;
complete behaviors positive, negative;
disjoint behaviors positive, negative;
*/
int abs(int n){
if(n<0){
return -n;
}
return n;
}
| 14
|
#include <limits.h>
/*@
requires (x > INT_MIN) && (y > INT_MIN) && (x >= y && x - y <= INT_MAX || x < y && x - y >= INT_MIN);
ensures y == x-\result;
assigns \nothing;
*/
int diff (int x, int y) {
return x-y;
}
/*@ assigns \nothing; */
void main() {
int t = diff(10, 5);
//@ assert t == 5;
}
| 13
|
#include "limits.h"
/*@ requires b != 0;
@ requires !(a == INT_MIN && b == -1);
@ ensures \result == a/b;
@ assigns \nothing;
@*/
int div(int a, int b) {
return a / b;
}
| 6
|
/* run.config
OPT: -rpp
*/
/*
* Based on http://stackoverflow.xluat.com/questions/31235938/java-order-by-priority-list
*
*/
struct MyClass{
int Name;
};
struct hack{
int t[3];
};
/*@ assigns \result \from x,y;
@ ensures x < y ==> \result == -1;
@ ensures x > y ==> \result == 1;
@ ensures x == y ==> \result == 0;
*/
int IntCompare(int x, int y){
if (x < y){
return -1;
}
if(x > y){
return 1;
}
return 0;
}
/*@ assigns \result \from o1.Name, o2.Name, h.t[0..2];
@ ensures \result == -1 || \result == 0 || \result == 1;
*/
int compare(struct MyClass o1, struct MyClass o2,struct hack h){
int x = o1.Name;
int y = o2.Name;
int i = 0;
/*@ loop invariant 0 <= i <= 3;
loop invariant \forall integer k; 0 <= k < i ==> h.t[k] != x && h.t[k] != y;
loop invariant \forall integer k; 0 <= k < 3 ==> h.t[k] == \at(h.t[k],LoopEntry);
loop assigns i;
loop variant 3 - i;
*/
while(i < 3){
/*@ assert \forall integer k; 0 <= k < i ==> h.t[k] != x && h.t[k] != y; */
if(h.t[i] == x) {
return 1;
}
if(h.t[i] == y) {
return -1;
}
i++;
}
return IntCompare(x,y);
}
| 34
|
/*@ requires n>0;
requires \valid(t+(0..n-1));
assigns t[0..n-1];
ensures \forall integer i; 0<=i<n ==> t[i] == i ;
ensures \forall integer i; 0<=i<n-1 ==> t[i] <= t[i+1];
*/
int doubleint(int t[],int n) {
/*@ loop invariant 0<=i<=n;
loop invariant \forall integer j; 0<=j<i ==> t[j] == j ;
loop assigns i, t[0..n-1];
loop variant n-i;
*/
for(int i=0;i<n;i++) {
t[i]=i;
}
return 0;
}
| 17
|
/*@
requires \valid(t+(0..taille-1)) && taille>0;
assigns \nothing;
ensures (\forall integer i; 0<=i<taille-1 ==> t[i]<=t[i+1]) ==> \result==1;
ensures (\exists integer i; 0<=i<taille-1 && t[i]>t[i+1]) ==> \result==0;
*/
int increasing(int t[], int taille){
/*@
loop invariant 0<=i<=taille-1;
loop invariant \forall integer j; 0<=j<i ==> t[j]<=t[j+1];
loop assigns i;
loop variant taille-i-1;
*/
for(int i=0;i<taille-1;i++){
if(t[i]>t[i+1]) return 0;
}
return 1;
}
| 19
|
#pragma CIVL ACSL
enum t{RED, BLUE};
/*@ requires \valid_read(a) && *a==BLUE;
@ ensures \result == 2;
@ assigns \nothing;
@*/
int f(enum t* a){
return (*a)*2;
}
| 5
|
/*@
requires n > 0;
requires \valid_read(a + (0..n-1));
ensures \forall integer i; 0 <= i < n ==> \result <= a[i];
*/
int Min_elements(int a[], int n)
{
int min = a[0];
/*@
loop invariant 1 <= j <= n;
loop invariant \forall integer k; 0 <= k < j ==> min <= a[k];
loop assigns j, min;
loop variant n - j;
*/
for (int j = 1; j < n; j++)
{
if (a[j] < min)
min = a[j];
}
return min;
}
| 14
|
#include <limits.h>
/*@
requires INT_MIN <= a - b <= INT_MAX;
ensures (\result == a - b);
assigns \nothing;
*/
int sub(int a,int b)
{
int diff = a - b;
return diff;
}
/*@ assigns \nothing; */
int main(void)
{
int a = 7;
int b = 6;
sub(a,b);
return 0;
}
| 12
|
/*@ requires \valid_read(t+(0..tt-1)) && tt>0;
requires \valid_read(s+(0..ts-1)) && ts>0;
requires \valid(r+(0..tt+ts-1));
requires 0<tt<100;
requires 0<ts<100;
requires \separated(t+(0..tt-1), s+(0..ts-1), r+(0..tt+ts-1));
ensures \forall integer i; 0<=i<tt ==> r[i]==t[i];
ensures \forall integer j; 0<=j<ts ==> r[j+tt]==s[j];
assigns r[0..tt+ts-1];
*/
void concat(int t[], int tt, int s[], int ts, int r[]){
/*@ loop invariant 0<=i<=tt;
loop invariant \forall integer j; 0<=j<i ==> r[j]==t[j];
loop assigns i, r[0..tt+ts-1];
loop variant tt-i;
*/
for(int i=0;i<tt;i++){
/*@ assert \forall integer j; 0<=j<i ==> r[j]==t[j]; */
r[i]=t[i];
}
/*@ loop invariant 0<=i<=ts;
loop invariant \forall integer j; 0<=j<tt ==> r[j]==t[j];
loop invariant \forall integer j; 0<=j<i ==> r[j+tt]==s[j];
loop assigns i, r[0..tt+ts-1];
loop variant ts-i;
*/
for(int i=0;i<ts;i++){
/*@ assert \forall integer j; 0<=j<tt ==> r[j]==t[j]; */
r[i+tt]=s[i];
}
}
| 36
|
#include "limits.h"
/*@
requires
a*x <= INT_MAX
&& a*x+b <= INT_MAX
&& a*x >= INT_MIN
&& a*x+b >= INT_MIN;
ensures \result >= INT_MIN && \result <= INT_MAX && \result == a*x+b;
*/
int f(int a,int b,int x) {
return a*x+b;
}
| 7
|
/*@ requires \valid(t+(0..n-1)) && n>0;
behavior success:
assumes \exists integer i; 0<=i<n && t[i]==val;
ensures 0<=\result<n;
behavior failure:
assumes \forall integer i; 0<=i<n ==> t[i]!=val;
ensures \result==-1;
complete behaviors success, failure;
disjoint behaviors success, failure;
*/
int index(int t[], int val, int n){
/*@ loop invariant 0<=i<=n;
loop invariant \forall integer j; 0<=j<i ==> t[j]!=val;
loop assigns i;
loop variant n-i;
*/
for(int i=0;i<n;i++){
if(t[i]==val) return i;
}
return -1;
}
| 15
|
/*@
requires \valid(t+(0..n-1)) && n > 0;
ensures \forall integer i; 0<=i<n ==> t[\result] <= t[i];
ensures \exists integer i; 0<=i<n && i == \result;
assigns \nothing;
*/
int min(int t[], int n) {
int index = 0;
/*@
loop invariant 1 <= i <= n;
loop invariant 0<=index<n;
loop invariant \forall integer j; 0<=j<i ==> t[index] <= t[j];
loop assigns index, i;
loop variant n - i;
*/
for (int i = 1; i < n; i++){
if (t[i] < t[index]) {
index=i;
//@ assert \forall integer j; 0 <= j < i ==> t[index] <= t[j];
}
}
return index;
}
| 18
|
/*@ requires \valid_read(p+(0..n-1));
@ ensures \result == 0;
@ assigns \nothing;
@ */
int somefun(char *p, int n) {
return 0;
}
| 4
|
/* run.config
OPT: -rpp
*/
/*
* Based on http://stackoverflow.com/questions/23907134/comparing-two-arrays-using-dictionary-order-in-an-array-of-arrays-java
*
*/
struct AInt{
int t[10];
int length;
};
/*@ requires 0 <= o1.length && o1.length <= 10;
@ requires 0 <= o2.length && o2.length <= 10;
@ assigns \result \from o1,o2;
*/
int compare(struct AInt o1, struct AInt o2){
int index, aentry, bentry;
index = 0;
/*@ loop invariant 0 <= index && index <= o2.length && index <= o1.length;
@ loop invariant \forall integer k; 0 <= k < index ==> o1.t[k] == o2.t[k];
@ loop assigns index,aentry,bentry;
@ loop variant o1.length - index;
*/
while ((index < o1.length) && (index < o2.length)) {
aentry = o1.t[index];
bentry = o2.t[index];
if (aentry < bentry) {
return -1;
}
if (aentry > bentry) {
return 1;
}
index++;
}
if (o1.length < o2.length) return -1;
if (o1.length > o2.length) return 1;
return 0;
}
| 23
|
/*@ ensures (x==0||y==1)?\result==1:\result == 0;
assigns \nothing;
*/
int f(int x, int y) { return (x==0||y==1); }
/*@ assigns \nothing; */
int main() {
int x = f(42,1);
int y = f(0,36);
return 0;
}
| 14
|
/*@ requires 0 <= n <= 1000;
ensures \result == n*(n-1)/2;
*/
int sum(int n){
int res=0;
/*@ loop invariant 0<=i<=n;
loop invariant res == i*(i-1)/2;
loop assigns res, i;
loop variant n-i;
*/
for(int i=0;i<n;i++) {
res+=i;
}
return res;
}
| 13
|
struct S { int x; };
#include <limits.h>
/*@
requires \valid(s);
assigns s->x;
ensures s->x == 0;
*/
void reset (struct S* s) {
s->x = 0;
}
/*@
requires \valid(s);
requires s->x < INT_MAX;
assigns s->x;
ensures s->x > \at(s->x,Pre);
*/
void inc(struct S* s) {
//@ assert s->x < INT_MAX;
s->x++;
}
/*@
requires \valid(s);
requires s->x > INT_MIN;
assigns s->x;
ensures s->x < \at(s->x,Pre);
*/
void dec(struct S* s) {
//@ assert s->x > INT_MIN;
s->x--;
}
/*@
requires \valid(s);
assigns \nothing;
behavior is_true:
assumes s->x > 0;
ensures \result == 1;
behavior is_false:
assumes s->x <= 0;
ensures \result == 0;
complete behaviors is_true, is_false;
disjoint behaviors is_true, is_false;
*/
int is_pos(struct S* s) {
return s->x > 0;
}
| 29
|
/*@ requires b != 0 && (a != -2147483648 || b != -1); // Prevent potential overflow
assigns \nothing;
ensures \result == (a % b);
*/
int mod(int a, int b)
{
return a % b;
}
| 6
|
#include <stdbool.h>
/*@
requires \valid(t1+(0..n-1)) && \valid(t2+(0..n-1)) && n>0;
ensures (\forall integer i; 0<=i<n ==> t1[i] == t2[i]) ==> \result==1;
ensures (\exists integer i; 0<=i<n && t1[i] != t2[i]) ==> \result==0;
assigns \nothing;
*/
int compare(int t1[], int t2[], int n){
int i=0;
bool diff_found = 0;
/*@
loop invariant 0<=i<=n;
loop invariant (\forall integer j; 0<=j<i ==> t1[j] == t2[j]) || (i == 0);
loop invariant !diff_found ==> (\forall integer j; 0<=j<i ==> t1[j] == t2[j]);
loop invariant diff_found ==> (\exists integer j; 0<=j<i && t1[j] != t2[j]);
loop assigns i, diff_found;
loop variant n-i;
*/
for(i=0;i<n;i++)
{
if(t1[i] != t2[i])
{
diff_found = 1;
return 0;
}
}
return 1;
}
| 23
|
/*@
requires \valid_read(t+(0..n-1)) && n > 0;
ensures \forall integer i; 0<=i<n ==> \result <= t[i];
ensures \exists integer i; 0<=i<n && t[i] == \result;
assigns \nothing;
*/
int min(int t[], int n) {
int res = t[0];
/*@
loop invariant 1 <= i <= n;
loop invariant \forall integer j; 0 <= j < i ==> res <= t[j];
loop invariant \exists integer j; 0 <= j < i && res == t[j];
loop assigns res, i;
loop variant n - i;
*/
for (int i = 1; i < n; i++)
if (t[i] < res) res = t[i];
return res;
}
| 18
|
/*@
axiomatic LCM {
logic integer lcm(integer m, integer n);
}
*/
/*@ requires a>0 && b>0;
decreases a+b;
assigns \nothing;
ensures a == 0 ==> \result == b;
ensures b == 0 ==> \result == a;
ensures a == b ==> \result == a;
*/
int gcd(int a, int b) {
if (a == 0)
return b;
if (b == 0)
return a;
if (a == b)
return a;
if (a > b)
return gcd(a-b, b);
return gcd(a, b-a);
}
/*@ assigns \nothing; */
int main()
{
int a = 98, b = 56;
return 0;
}
| 25
|
/* run.config
OPT: -load-module lib/plugins/Obfuscator -obfuscate -journal-disable
*/
/*@ ensures \valid(q);
*/
int f(int *q) ;
#define LV X_9999999999999999999999999999999999999999999999999999
int global_LV;
enum { OK = 1,
NOT_OK = 0 } e ;
/*@ ensures \valid(p);
*/
void main (int * p) {
int LV = 0;
e = OK ;
f(p);
}
| 3
|
/*@
requires \valid (s+(0..n-1));
requires \valid (t+(0..n-1));
requires n > 0;
assigns \nothing;
ensures \result <==> (\forall integer i; 0 <= i < n ==> s[i] == t[i]);
*/
int compare_array(int s[], int t[], int n)
{
int i = 0;
/*@
loop invariant \forall integer j; 0 <= j < i ==> s[j] == t[j];
loop invariant 0 <= i <= n;
loop assigns i;
loop variant n-i;
*/
while (i < n && s[i] == t[i])
{
i++;
}
return i == n;
}
| 15
|
/*@
@ requires n > 0;
@ requires \valid(a+(0..n-1));
@
@ assigns \nothing;
@ behavior true_:
@ assumes \forall integer i; 0 <= i < n / 2 ==> a[i] == a[n - i - 1];
@ ensures \result == 1;
@ behavior false_:
@ assumes \exists integer i; 0 <= i < n / 2 && a[i] != a[n - i - 1];
@ ensures \result == 0;
@ complete behaviors true_, false_;
@ disjoint behaviors true_, false_;
*/
int palindrome(int a[], int n) {
/*@
@ loop invariant 0 <= i <= n / 2;
@ loop invariant \forall integer j; 0 <= j < i ==> a[j] == a[n - j - 1];
@ loop assigns i;
@ loop variant n - 2 * i;
*/
for (int i = 0; i < n / 2; ++i) {
if (a[i] != a[n - i - 1]) return 0;
}
return 1;
}
| 22
|
/* bts 60: 1 should be lifted to a real number implicitely. */
/*@ ensures 1.0 == 1;
assigns \nothing;*/
void f();
/*@ lemma foo: 1.0 == (float)1; */
void f() {
double B;
}
typedef int T, T4[4], *T_PTR;
const T X, Tab[4];
typedef T_PTR T_PTR_T4[4];
const T_PTR_T4 Tab_Ptr = { &X, &X, &X, &X};
| 5
|
/*@ predicate dom{L}(int k,int n) = k >= 0 && k <= n - 1;
*/
/*@
requires A: n >= 0 && \valid (a +(0.. n-1));
requires B: dom( i, n ) && dom( j, n );
assigns a[i], a[j];
ensures \old(a[i]) == a[j] && \old(a[j]) == a[i];
ensures \forall int i1; dom(i1,n) ==>
\exists int i2; dom(i2,n) && (a[i1] == \old(a[i2]));
*/
void swap3(int *a, int n, int i, int j) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
| 10
|
/* public interface */
/*@ assigns \nothing;
@ ensures \result >= 0;
@*/
int gen() {
return 0;
}
| 4
|
/*@ requires \valid_read(p+(0..n-1));
@ ensures \result > 0;
@ assigns \nothing;
@ */
int somefun(char *p, int n) {
return 1;
}
| 4
|
/*@
requires n > 0;
requires \valid_read(arr + (0..n-1));
ensures \forall integer i; 0 <= i < n ==> \result >= arr[i];
*/
int arraymax(int arr[], int n) {
int max = arr[0];
/*@
loop invariant 1 <= j <= n;
loop invariant \forall integer i; 0 <= i < j ==> max >= arr[i];
loop invariant max >= arr[0];
loop assigns j, max;
loop variant n - j;
*/
for (int j=1; j<n; j++)
{
if (arr[j] > max)
max = arr[j];
}
return max;
}
| 16
|
/*@ requires 0 <= n <= 1000;
ensures \result == n*n;
assigns \nothing;
*/
int oddsum(int n) {
int sum=0;
/*@ loop invariant 0<=i<=n;
loop invariant sum==i*i;
loop assigns i, sum;
loop variant n-i;
*/
for(int i=0;i<n;i++) {
sum += i*2 + 1;
}
return sum;
}
| 17
|
/* run.config
EXECNOW: make tests/aorai/Aorai_test.cmxs
OPT: -aorai-automata tests/aorai/test_boucle_rechercheTableau.ya -aorai-test 1 -aorai-acceptance -load-module tests/aorai/Aorai_test.cmxs -aorai-test-number @PTEST_NUMBER@
*/
/*@ requires \valid(t+(0..max));
@ requires max>=0;
@ requires max < 2147483647;
@ ensures 0<=\result && \result<=max || \result==-1 ;
@ ensures 0<=\result && \result<=max ==> t[\result]==val;
@ ensures \result==-1 ==> (\forall integer j; 0<=j<=max ==> t[j]!=val);
@ assigns \nothing;
*/
int isPresent(int t[], int max, int val) {
int i=0;
/*@ loop invariant inv :
@ 0<=i<=max+1
@ && \valid(t+(0..max))
@ && max>=0
@ && (\forall integer j; 0<=j<i ==> t[j]!=val);
@ loop assigns i;
@ loop variant v : max-i ;
*/
while (i<max+1 && t[i]!=val) {
i++;
}
if(i<=max && t[i]==val) return i;
return -1;
}
/*@ assigns \nothing; */
void foo(){}
/*@ assigns \nothing; */
int main(int argc, char** argv) {
int tab[]={10,20,33,15};
int r=isPresent(tab, 3, 33);
if (r==-1) foo();
return 1;
}
| 30
|
/*@
requires \valid_read(a + (0..n-1));
requires n > 0;
ensures \forall integer k; 0 <= k < n ==> \result >= a[k];
ensures \exists integer k; 0 <= k < n && \result == a[k];
assigns \nothing;
*/
int arraymax(int* a, int n) {
int i = 1;
int max = a[0];
/*@
loop invariant \forall integer k; 0 <= k < n ==> (k < i ==> max >= a[k]);
loop invariant \exists integer k; 0 <= k < i && max == a[k];
loop invariant 0 <= i <= n;
loop assigns i,max;
loop variant n - i;
*/
while (i < n) {
// Beginning of loop
if (max < a[i])
max = a[i];
i = i + 1;
// End of loop: Loop invariant comes here
}
return max;
}
| 18
|
/*@ requires 1000>taille>0;
requires \valid(t+(0..taille-1));
ensures \forall integer i; 0<=i<taille ==> t[i] == (i*2) ;
ensures \forall integer i; 0<=i<taille-1 ==> t[i]<=t[i+1];
*/
void doubleint(int t[],int taille) { // void double() --> not possible since datatype!
/*@ loop invariant 0<=i<=taille;
loop invariant \forall integer j; 0<=j<i ==> t[j] == (j*2) ;
loop invariant \forall integer j; 0<=j<i-1 ==> t[j]<=t[j+1];
loop assigns t[0..taille-1],i;
loop variant taille-i;
*/
for(int i=0;i<taille;i++) {
t[i]=i*2;
}
}
| 19
|
/*@
requires \valid(t+(0..n-1)) && n>0;
// assigns \nothing;
ensures (\forall integer i; 0<=i<n ==> t[i] == t[n-i-1]) ==> \result==1;
ensures (\exists integer i; 0<=i<n && t[i] != t[n-i-1]) ==> \result==0;
*/
int palindrome(int t[], int n){
/*@
loop invariant 0<=i<=n/2;
loop invariant \forall integer j; 0<=j<i ==> t[j] == t[n - j - 1];
loop assigns i;
loop variant n/2-i;
*/
for (int i = 0; i < n / 2; i++) {
if (t[i] != t[n - i - 1])
return 0;
}
return 1;
}
| 17
|
/*
* A simple string matching
* Takuo Watanabe (Tokyo Institute of Technology)
*
* This file can be successfully verified using Frama-C with Jessie plugin.
* Frama-C Carbon-20110201
* Alt-Ergo 0.92.2 / CVC3 2.2
*/
/*@ predicate MatchAt{L}(char *t, char *p, integer k, integer m) =
@ \forall integer l; 0 <= l < m ==> t[k + l] == p[l];
@*/
/*@ predicate Match{L}(char *t, integer n, char *p, integer m) =
@ \exists integer k; 0 <= k <= n - m && MatchAt(t, p, k, m);
@*/
// Needed to prove (in ATP) that the loop variant >= 0
/*@ lemma nzmul:
@ \forall integer x, y; x >= 0 ==> y >= 0 ==> x * y >= 0;
@*/
/*@ requires n >= 0 && \valid(t+(0..n-1));
@ requires m >= 0 && \valid(p+(0..m-1));
@ assigns \nothing;
@ behavior success:
@ assumes Match(t, n, p, m);
@ ensures 0 <= \result <= n - m && MatchAt(t, p, \result, m);
@ ensures \forall integer k;
@ 0 <= k < \result ==> !MatchAt(t, p, k, m);
@ behavior failure:
@ assumes !Match(t, n, p, m);
@ ensures \result == -1;
@ complete behaviors success, failure;
@ disjoint behaviors success, failure;
@*/
int smatch (char t[], int n, char p[], int m) {
int i = 0, j = 0;
/*@ loop invariant 0 <= i <= n && 0 <= j <= m;
@ loop invariant i >= j;
@ loop invariant MatchAt(t, p, i - j, j);
@ loop invariant \forall integer k; 0 <= k < i - j ==> !MatchAt(t, p, k, m);
@ loop assigns i, j;
@ loop variant m * (n - (i - j)) + (m - j);
@*/
while (i < n && j < m) {
if (t[i] == p[j]) {
i++;
j++;
}
else {
i = i - j + 1;
j = 0;
}
}
return j == m ? i - j : -1;
}
| 31
|
/*@
requires 0 <= n <= 1000;
ensures \result == n*(n-1)/2;
*/
int sum(int n){
int sum=0;
/*@
loop invariant 0<=i<=n;
loop invariant sum == i*(i-1)/2;
loop assigns i, sum;
loop variant n-i;
*/
for (int i=0;i<n;i++)
sum += i;
return sum;
}
| 13
|
/*@
requires 0 <= n <= 1000;
ensures \result == n * n;
assigns \nothing;
*/
int sumOdd(int n){
int res=0;
int i=0;
/*@
loop invariant 0<=i<=n;
loop invariant res == i*i;
loop assigns res,i;
loop variant n-i;
*/
while(i<n){
res+=i*2+1;
i++;
}
return res;
}
| 17
|
/*@
requires \valid_read(a+(0..N-1)) && 0 <= x && x < N && 0 <= y && y < N;
ensures \result >= 0;
*/
int lcp(int a[], int N, int x, int y)
{
int l = 0;
/*@ loop invariant 0 <= l <= N;
loop invariant x + l <= N && y + l <= N;
loop assigns l;
loop variant N - l;
*/
for (;;) {
if (!(x + l < N && y + l < N && a[x+l] == a[y+l])) {
break;
}
l++;
}
return l;
}
| 21
|
/*@
requires n > 0;
requires \valid_read(t+(0..n-1));
ensures \result <==> (\forall integer i; 0 <= i < n ==> t[i] == 0);
*/
int arraynull(int t[], int n){
/*@
loop invariant 0 <= i <= n;
loop invariant \forall integer j ; 0 <= j < i ==> t[j] == 0;
loop assigns i;
loop variant n-i;
*/
for(int i = 0; i < n ; i++){
if (t[i] != 0) {
return 0;
}
}
return 1;
}
| 12
|
/*@
ensures \result == x || \result == y;
ensures \result >= x && \result >= y;
*/
int max(int x, int y) {
if (x >= y) {
return x;
}
return y;
}
| 4
|
/*@ requires n>=0 && \valid(t+(0..n-1));
ensures \result != 0 <==> (\forall integer j; 0 <= j < n ==> t[j] == 0);
*/
int all_zeros(int t[], int n) {
int k;
/*@ loop invariant 0 <= k <= n;
loop invariant \forall integer j; 0 <= j < k ==> t[j] == 0;
loop assigns k;
loop variant n-k;
*/
for(k = 0; k < n; k++)
if (t[k] != 0)
return 0;
return 1;
}
| 12
|
/*@ requires n > 0;
requires \valid_read(a + (0..n-1));
assigns \nothing;
behavior present:
assumes \exists integer k; 0 <= k < n && x == a[k];
ensures \result == 1;
assigns \nothing;
behavior not_present:
assumes \forall integer k; 0 <= k < n ==> x != a[k];
ensures \result == 0;
assigns \nothing;
complete behaviors present, not_present;
disjoint behaviors present, not_present;
*/
int arraysearch(int* a, int x, int n) {
/*@ loop invariant 0 <= p <= n;
loop invariant \forall integer k; 0 <= k < p ==> x != a[k];
loop assigns p;
loop variant n - p;
*/
for (int p = 0; p < n; p++) {
if (x == a[p])
return 1;
}
return 0;
}
| 24
|
#include <limits.h>
/*@
assigns \nothing;
*/
void try_initialize_array ( void )
{
int array[5];
// To prove asserts at the end of this function,
// uncomment following loop invariant. It might also be helpful to ensure
// that i has proper bounds (or use -wp-invariants).
/*@ loop invariant I1:
0 <= i <= 5 &&
( \forall integer j; 0 <= j < i ==> array[j] == 1 - j);
loop assigns i, array[0 .. 4];
loop variant 5 - i; */
for (int i = 0; i < 5; i++)
{
// Try uncommenting one of following lines:
// i = -1; // Runtime error
// i = 0; // No error, but does not terminate. Invariant is preserved
array[i] = 1 - i;
}
if ( array[2] == -2 )
array[2]++;
/*@ assert array[2] != -2; */
/*@ assert array[3] == -2; */
}
/*@
requires len > 0;
requires \valid ( array + ( 0 .. len - 1 ) );
// In specifications we use mathematical integers.
requires len + base_value < INT_MAX;
// i++ may overflow elsewhere
requires len < INT_MAX;
assigns array[0 .. len-1];
ensures \forall integer i; 0 <= i < len ==>
array [i] == base_value + i;
*/
void try_initialize_given_array ( int *array, int len, int base_value )
{
/*@
loop invariant
// WP somehow knows this
0 <= i <= len &&
(
\forall integer j; 0 <= j < i ==>
array[j] == base_value + j
);
// BTW an error happens when using this syntax:
// loop assigns array + (0 .. len - 1);
// It is easy to forget 'i'
loop assigns i, array[0 .. len - 1];
loop variant len - i;
*/
for ( int i = 0; i < len; i++)
{
array[i] = base_value + i;
}
}
/*@
assigns \nothing;
*/
int main ( int argc, char *argv[] )
{
try_initialize_array();
int array[17];
try_initialize_given_array ( array, 5, 0 );
/*@ assert array[1] == 1; */
/*@ assert array[3] == 3; */
try_initialize_given_array ( array + 3, 11, 5 );
/*@ assert \forall integer i; 0 <= i < 11 ==> array[i+3] == 5 + i; */
/*@ assert \forall integer i; 0 <= i < 11 ==> array[i+3] == 5 + i; */
/*@ assert array[8+3] == 5 + 8; */
/*@ assert array[11] == 13; */
// This fails, because precondition is not met
//try_initialize_given_array ( array, 18, 0 );
return 0;
}
| 54
|
/*@
requires c >= 0;
assigns \nothing;
ensures \true;
*/
void f (int c) {
/*@ loop invariant c >= 0;
loop invariant c <= \at(c, Pre);
loop assigns c;
loop variant c;
*/
while (c != 0) {
c--;
}
return;
}
| 12
|
#ifndef _FIND_H_
#define _FIND_H_
/*@
requires \valid_read(a + (0..n-1));
ensures 0 <= \result <= n;
behavior some:
assumes \exists integer i; 0 <= i < n && a[i] == v;
ensures 0 <= \result < n;
ensures a[\result] == v;
ensures \forall integer i; 0 <= i < \result ==> a[i] != v;
behavior none:
assumes \forall integer i; 0 <= i < n ==> a[i] != v;
ensures \result == n;
assigns \nothing;
complete behaviors some, none;
disjoint behaviors some, none;
*/
unsigned int find(const int* a, unsigned int n, int v) {
/*@ loop invariant 0 <= i <= n;
loop invariant \forall integer j; 0 <= j < i ==> a[j] != v;
loop assigns i;
loop variant n-i;
*/
for (unsigned int i = 0; i < n; i++) {
/*@ assert 0 <= i <= n; */
if (a[i] == v) {
return i;
}
}
return n;
}
#endif
| 21
|
/*@
requires \valid(t+(0..taille-1)) && taille>0 && 2*(taille-1) < 2147483647;
assigns t[0..taille-1];
ensures \forall integer i; 0<=i<taille ==> t[i] == 2*i;
*/
void doubled(int t[], int taille){
/*@
loop invariant 0 <= i <= taille;
loop invariant \forall integer j; 0 <= j < i ==> t[j] == 2*j;
loop assigns i, t[0..taille-1];
loop variant taille-i;
*/
for (int i=0; i<taille; i++) {
t[i] = 2*i;
/*@ assert t[i] == 2*i; */
}
}
| 18
|
/*@
requires \valid(t+(0..taille-1)) && taille>0;
behavior increasing:
assumes \forall integer i; 1 <= i < taille ==> t[i] >= t[i - 1];
ensures \result == 1;
behavior decreasing:
assumes \exists integer i; 1 <= i < taille && t[i] < t[i - 1];
ensures \result == 0;
assigns \nothing;
complete behaviors increasing, decreasing;
disjoint behaviors increasing, decreasing;
*/
int monotonic(int t[], int taille) {
int i;
/*@
loop invariant 1 <= i <= taille;
loop invariant \forall integer j; 1 <= j < i ==> t[j] >= t[j - 1];
loop assigns i;
loop variant taille - i;
*/
for (i = 1; i < taille; i++) {
if (t[i] < t[i - 1])
return 0;
}
return 1;
}
| 21
|
/*@ requires n>0;
requires \valid(a+(0..n-1));
assigns \nothing;
behavior success:
assumes \forall integer i; 0<=i<n ==> a[i]==a[n-i-1];
ensures \result==1;
behavior failure:
assumes \exists integer i; 0<=i<n && a[i]!=a[n-i-1];
ensures \result==0;
complete behaviors success, failure;
disjoint behaviors success, failure;
*/
int palindrome(int a[],int n) {
/*@ loop invariant 0<=i<=n;
loop invariant \forall integer j; 0<=j<i ==> a[j]==a[n-1-j];
loop assigns i;
loop variant n-i;
*/
for(int i=0;i<n;i++) {
if(a[i]!=a[n-i-1]) return 0;
}
return 1;
}
| 22
|
/*@ requires length > 0 && \valid(a+(0..length-1));
assigns \nothing; // Changed assigns clause to \nothing
ensures 0<=\result<length &&
(\forall integer j; 0<=j<length ==> a[\result]<=a[j]);
*/
int find_min(int* a, int length) {
int min, min_idx;
min_idx = 0;
min = a[0];
/*@ loop invariant 0<=i<=length ;
loop invariant 0<=min_idx<length;
loop invariant \forall integer j; 0<=j<i ==> min<=a[j];
loop invariant a[min_idx]==min;
loop assigns min, min_idx, i;
loop variant length - i; */
for (int i = 1; i<length; i++) { // Corrected loop condition to i < length
if (a[i] < min) {
min_idx = i; /* min_idx = i; */
min = a[i];
}
}
return min_idx;
}
| 21
|
/*@ requires \valid(a) && \valid(b);
@ ensures *a == \old(*b);
@ ensures *b == \old(*a);
@*/
void swap(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
| 8
|
struct S {
char *x;
int *y;
};
/*@
requires \valid(s) && \valid_read(s->x) && \valid_read(s->y) &&
(int)(*s->x) + *s->y >= -2147483648 && (int)(*s->x) + *s->y <= 2147483647;
ensures \result == (int)(*s->x) + *s->y;
assigns \nothing;
*/
int f(struct S* s) {
return *s->x + *s->y;
}
| 10
|
// teste si un tableau est un palindrome
// ESOPE RESTE ELU PAR CETTE CRAPULE ET SE REPOSE
/*@
requires \valid (t+(0..n-1));
requires n > 0;
assigns \nothing;
ensures \result <==> (\forall integer i; 0 <= i < n/2 ==> t[i] == t[n-i-1]);
*/
int is_palindrome(int t[], int n)
{
int mid = n/2;
int i = 0;
/*@
loop invariant 0 <= i <= mid;
loop invariant \forall integer j; 0 <= j < i ==> t[j] == t[n-1-j];
loop assigns i;
loop variant mid - i;
*/
while (i < mid && t[i] == t[n-i-1])
{
i++;
}
return i == mid;
}
| 18
|
/*@
requires \valid(a) && \valid(b) && \valid_read(a) && \valid_read(b);
assigns *a, *b;
ensures *a == \old(*b);
ensures *b == \old(*a);
*/
void foo(int* a, int* b) {
int tmp = *a;
*a = *b;
*b = tmp;
}
| 10
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.