#!/usr/bin/env python
|
#!/usr/bin/env python
|
import os
|
import os
|
import sys
|
import sys
|
|
|
os.system("python-coverage erase")
|
os.system("python-coverage erase")
|
|
|
def test(test, code, no_init=False):
|
def test(test, code, no_init=False):
|
f = open("test.c", 'w')
|
f = open("test.c", 'w')
|
f.write(code)
|
f.write(code)
|
f.close()
|
f.close()
|
if no_init:
|
if no_init:
|
result = os.system("python-coverage run -p ../c2verilog iverilog run no_initialize_memory test.c")
|
result = os.system("python-coverage run -p ../c2verilog iverilog run no_initialize_memory test.c")
|
else:
|
else:
|
result = os.system("python-coverage run -p ../c2verilog iverilog run test.c")
|
result = os.system("python-coverage run -p ../c2verilog iverilog run test.c")
|
if(os.path.exists("main")):
|
if(os.path.exists("main")):
|
os.remove("main")
|
os.remove("main")
|
if(os.path.exists("arbiter")):
|
if(os.path.exists("arbiter")):
|
os.remove("arbiter")
|
os.remove("arbiter")
|
if(os.path.exists("real_main")):
|
if(os.path.exists("real_main")):
|
os.remove("real_main")
|
os.remove("real_main")
|
|
|
if result == 0:
|
if result == 0:
|
print test, "...pass"
|
print test, "...pass"
|
else:
|
else:
|
print test, "...fail"
|
print test, "...fail"
|
sys.exit(0)
|
sys.exit(0)
|
|
|
if no_init:
|
if no_init:
|
result = os.system("python-coverage run -p ../c2verilog iverilog run speed no_initialize_memory test.c")
|
result = os.system("python-coverage run -p ../c2verilog iverilog run speed no_initialize_memory test.c")
|
else:
|
else:
|
result = os.system("python-coverage run -p ../c2verilog iverilog run speed test.c")
|
result = os.system("python-coverage run -p ../c2verilog iverilog run speed test.c")
|
if(os.path.exists("main")):
|
if(os.path.exists("main")):
|
os.remove("main")
|
os.remove("main")
|
if(os.path.exists("arbiter")):
|
if(os.path.exists("arbiter")):
|
os.remove("arbiter")
|
os.remove("arbiter")
|
if(os.path.exists("real_main")):
|
if(os.path.exists("real_main")):
|
os.remove("real_main")
|
os.remove("real_main")
|
|
|
if result == 0:
|
if result == 0:
|
print test, "...pass"
|
print test, "...pass"
|
else:
|
else:
|
print test, "...fail"
|
print test, "...fail"
|
sys.exit(0)
|
sys.exit(0)
|
|
|
def test_fails(test, code, no_init=False):
|
def test_fails(test, code, no_init=False):
|
f = open("test.c", 'w')
|
f = open("test.c", 'w')
|
f.write(code)
|
f.write(code)
|
f.close()
|
f.close()
|
print "One error expected ..."
|
print "One error expected ..."
|
if no_init:
|
if no_init:
|
result = os.system("python-coverage run -p ../c2verilog iverilog run no_initialize_memory test.c")
|
result = os.system("python-coverage run -p ../c2verilog iverilog run no_initialize_memory test.c")
|
else:
|
else:
|
result = os.system("python-coverage run -p ../c2verilog iverilog run test.c")
|
result = os.system("python-coverage run -p ../c2verilog iverilog run test.c")
|
if result == 0:
|
if result == 0:
|
print test, "...fail"
|
print test, "...fail"
|
sys.exit(0)
|
sys.exit(0)
|
else:
|
else:
|
print test, "...pass"
|
print test, "...pass"
|
|
|
|
test("float file 1",
|
|
"""
|
|
void main(){
|
|
file_write(1.0, "test_file");
|
|
file_write(-1.0, "test_file");
|
|
file_write(2.0, "test_file");
|
|
file_write(-2.0, "test_file");
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float file 2",
|
|
"""
|
|
void main(){
|
|
assert(file_read("test_file") == 1.0);
|
|
assert(file_read("test_file") == -1.0);
|
|
assert(file_read("test_file") == 2.0);
|
|
assert(file_read("test_file") == -2.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test_fails("array size1",
|
|
"""
|
|
int size(){
|
|
return 10;
|
|
}
|
|
void main(){
|
|
int blah[size()];
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("array size2",
|
|
"""
|
|
void main(){
|
|
const int b = 10;
|
|
int a[b];
|
|
}
|
|
"""
|
|
)
|
|
|
|
test_fails("const 1",
|
|
"""
|
|
void main(){
|
|
const int blah = 10;
|
|
blah = 12;
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("const 2",
|
|
"""
|
|
void main(){
|
|
const int blah = 10;
|
|
assert(blah == 10);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test_fails("const 3",
|
|
"""
|
|
void main(){
|
|
const float blah = 10;
|
|
blah = 12;
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("const 4",
|
|
"""
|
|
void main(){
|
|
const float blah = 10;
|
|
assert(blah == 10.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test_fails("scope 1",
|
|
"""
|
|
void test(){
|
|
int test_var = 1;
|
|
}
|
|
|
|
void main(){
|
|
int blah = test_var;
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("inplace float 1",
|
|
"""
|
|
void main(){
|
|
float test = 1.0;
|
|
test *= 2.0;
|
|
assert(test == 2.0);
|
|
test *= 2.0;
|
|
assert(test == 4.0);
|
|
test *= 2.0;
|
|
assert(test == 8.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("inplace float 2",
|
|
"""
|
|
void main(){
|
|
float test = 1.0;
|
|
test += 2.0;
|
|
assert(test == 3.0);
|
|
test += 2.0;
|
|
assert(test == 5.0);
|
|
test += 2.0;
|
|
assert(test == 7.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("inplace float 3",
|
|
"""
|
|
void main(){
|
|
float test = 1.0;
|
|
test -= 2.0;
|
|
assert(test == -1.0);
|
|
test -= 2.0;
|
|
assert(test == -3.0);
|
|
test -= 2.0;
|
|
assert(test == -5.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("inplace float 4",
|
|
"""
|
|
void main(){
|
|
float test = 1.0;
|
|
test /= 2.0;
|
|
assert(test == 0.5);
|
|
test /= 2.0;
|
|
assert(test == 0.25);
|
|
test /= 2.0;
|
|
assert(test == 0.125);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("inplace float 5",
|
|
"""
|
|
void main(){
|
|
float test = 1.0;
|
|
test *= 2;
|
|
assert(test == 2.0);
|
|
test *= 2;
|
|
assert(test == 4.0);
|
|
test *= 2;
|
|
assert(test == 8.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("inplace float 6",
|
|
"""
|
|
void main(){
|
|
float test = 1.0;
|
|
test += 2;
|
|
assert(test == 3.0);
|
|
test += 2;
|
|
assert(test == 5.0);
|
|
test += 2;
|
|
assert(test == 7.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("inplace float 7",
|
|
"""
|
|
void main(){
|
|
float test = 1.0;
|
|
test -= 2;
|
|
assert(test == -1.0);
|
|
test -= 2;
|
|
assert(test == -3.0);
|
|
test -= 2;
|
|
assert(test == -5.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("inplace float 8",
|
|
"""
|
|
void main(){
|
|
float test = 1.0;
|
|
test /= 2;
|
|
assert(test == 0.5);
|
|
test /= 2;
|
|
assert(test == 0.25);
|
|
test /= 2;
|
|
assert(test == 0.125);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 1",
|
|
"""
|
|
void main(){
|
|
float test = 0.0;
|
|
assert(test == 0.0);
|
|
}
|
|
"""
|
|
)
|
|
test("float 2",
|
|
"""
|
|
void main(){
|
|
float test = 1.0;
|
|
assert(test > 0.0);
|
|
}
|
|
"""
|
|
)
|
|
test("float 3",
|
|
"""
|
|
void main(){
|
|
float test = 0.0;
|
|
assert(test < 1.0);
|
|
}
|
|
"""
|
|
)
|
|
test("float 4",
|
|
"""
|
|
void main(){
|
|
float test = 0.0;
|
|
float a = -1.0;
|
|
float b = -2.0;
|
|
float c = 2.0;
|
|
float d = 2.0;
|
|
assert(test > -1.0);
|
|
assert(a > b);
|
|
assert(b < a);
|
|
assert(c >= d);
|
|
assert(c <= d);
|
|
}
|
|
"""
|
|
)
|
|
test("float 5",
|
|
"""
|
|
void main(){
|
|
float test = 0.0;
|
|
assert(test == 0.0);
|
|
}
|
|
"""
|
|
)
|
|
test("float 6",
|
|
"""
|
|
void main(){
|
|
float blah[10];
|
|
blah[0] = 0.0;
|
|
blah[1] = 1.0;
|
|
blah[2] = 2.0;
|
|
blah[3] = 3.0;
|
|
assert(blah[0] == 0.0);
|
|
assert(blah[1] == 1.0);
|
|
assert(blah[2] == 2.0);
|
|
assert(blah[3] == 3.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 7",
|
|
"""
|
|
void main(){
|
|
float a = 2.0;
|
|
assert(a == 1.0 + 1.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 8",
|
|
"""
|
|
void main(){
|
|
float a = 2.0;
|
|
float b = 2.0;
|
|
assert(a+b == 4.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 9",
|
|
"""
|
|
void main(){
|
|
float a = -2.0;
|
|
float b = -2.0;
|
|
assert(a+b == -4.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 10",
|
|
"""
|
|
void main(){
|
|
float a = 2.0;
|
|
float b = 2.0;
|
|
assert(a-b == -0.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 11",
|
|
"""
|
|
void main(){
|
|
float a = 2.0;
|
|
float b = 4.0;
|
|
assert(a-b == -2.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 12",
|
|
"""
|
|
void main(){
|
|
float a = 1.0;
|
|
float b = 1.0;
|
|
assert(a*b == 1.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 13",
|
|
"""
|
|
void main(){
|
|
float a = 1.0;
|
|
float b = -1.0;
|
|
assert(a*b == -1.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 14",
|
|
"""
|
|
void main(){
|
|
float a = -1.0;
|
|
float b = -1.0;
|
|
assert(a*b == 1.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 15",
|
|
"""
|
|
void main(){
|
|
float a = -7.0;
|
|
float b = 6.0;
|
|
assert(a*b == -42.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 16",
|
|
"""
|
|
void main(){
|
|
float a = 6.0;
|
|
float b = 6.0;
|
|
assert(a/b == 1.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 17",
|
|
"""
|
|
void main(){
|
|
float a = 12.0;
|
|
float b = 6.0;
|
|
assert(a/b == 2.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 18",
|
|
"""
|
|
void main(){
|
|
int a = 2;
|
|
float b = 2.0;
|
|
assert(a+b == 4.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 19",
|
|
"""
|
|
void main(){
|
|
int a;
|
|
float b = 2.0;
|
|
a = b + 1.0;
|
|
assert(a == 3);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 20",
|
|
"""
|
|
void main(){
|
|
int a = 2;
|
|
float b;
|
|
b = a + 1.0;
|
|
assert(b == 3.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 21",
|
|
"""
|
|
typedef struct {float a; float b;} mystruct;
|
|
void main(){
|
|
mystruct a;
|
|
a.a = 2.0;
|
|
a.b = 3.0;
|
|
assert(a.a == 2.0);
|
|
assert(a.b == 3.0);
|
|
assert(a.a + a.b == 5.0);
|
|
}
|
|
"""
|
|
)
|
|
test("float 22",
|
|
"""
|
|
typedef struct {float a; float b;} mystruct;
|
|
|
|
void test(mystruct a){
|
|
assert(a.a == 2.0);
|
|
assert(a.b == 3.0);
|
|
assert(a.a + a.b == 5.0);
|
|
}
|
|
|
|
void main(){
|
|
mystruct a;
|
|
a.a = 2.0;
|
|
a.b = 3.0;
|
|
test(a);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 23",
|
|
"""
|
|
void test(float b){
|
|
assert(b/6.0 == 2.0);
|
|
}
|
|
|
|
void main(){
|
|
int a = 12.0;
|
|
test(a);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 24",
|
|
"""
|
|
float test(){
|
|
return 6.0;
|
|
}
|
|
|
|
void main(){
|
|
int a = 12.0;
|
|
assert(a/test() == 2.0);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("float 25",
|
|
"""
|
|
int main(){
|
|
float a = 1.0;
|
|
float b = 2.0;
|
|
float c = 3.0;
|
|
assert(a + b + c == 6.0);
|
|
return 0;
|
|
}
|
|
|
|
""")
|
|
|
|
test("float 26",
|
|
"""
|
|
int main(){
|
|
float a = 1.0;
|
|
float b = 2.0;
|
|
float c = 3.0;
|
|
assert(a - b - c == -4.0);
|
|
return 0;
|
|
}
|
|
|
|
""")
|
|
|
|
test("float 27",
|
|
"""
|
|
int main(){
|
|
float a = 1.0;
|
|
float b = 2.0;
|
|
float c = 3.0;
|
|
assert(a - (b - c) == 2.0);
|
|
return 0;
|
|
}
|
|
|
|
""")
|
|
|
|
test("float 28",
|
|
"""
|
|
int main(){
|
|
float a = 1.0;
|
|
float b = 2.0;
|
|
float c = 3.0;
|
|
assert(a * b * c == 6.0);
|
|
return 0;
|
|
}
|
|
|
|
""")
|
|
|
|
test("float 29",
|
|
"""
|
|
int main(){
|
|
float a = 1.0;
|
|
float b = 2.0;
|
|
float c = 4.0;
|
|
assert(a/b/c == 0.125);
|
|
return 0;
|
|
}
|
|
|
|
""")
|
|
|
|
test("float 30",
|
|
"""
|
|
int main(){
|
|
float a = 1.0;
|
|
float b = 2.0;
|
|
assert(a - - b == 3.0);
|
|
return 0;
|
|
}
|
|
|
|
""")
|
|
|
|
test("struct_size 1",
|
|
"""
|
|
|
|
typedef struct {int a; int b;} mystruct;
|
|
|
|
void main(){
|
|
assert(sizeof mystruct == 4);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("struct_size 2",
|
|
"""
|
|
|
|
typedef struct {long int a; int b;} mystruct;
|
|
|
|
void main(){
|
|
assert(sizeof mystruct == 6);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("struct_size 3",
|
|
"""
|
|
|
|
typedef struct {long int a; int b;} struct_1;
|
|
typedef struct {long int a; struct_1 b;} mystruct;
|
|
|
|
void main(){
|
|
assert(sizeof mystruct == 10);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("struct_size 4",
|
|
"""
|
|
|
|
typedef struct {long int a; int b[2];} mystruct;
|
|
|
|
void main(){
|
|
assert(sizeof mystruct == 6);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("struct_passing 1",
|
|
"""
|
|
|
|
typedef struct {int a; int b;} mystruct;
|
|
|
|
void test(mystruct mine){
|
|
assert(mine.a == 1);
|
|
assert(mine.b == 2);
|
|
}
|
|
|
|
void main(){
|
|
mystruct an;
|
|
an.a = 1;
|
|
an.b = 2;
|
|
test(an);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("struct_passing 2",
|
|
"""
|
|
|
|
typedef struct {long int a; int b;} struct_1;
|
|
typedef struct {long int a; struct_1 b;} mystruct;
|
|
|
|
void test(mystruct my){
|
|
assert(my.a == 1);
|
|
assert(my.b.a == 2);
|
|
assert(my.b.b == 3);
|
|
}
|
|
|
|
void main(){
|
|
mystruct blah;
|
|
blah.a = 1;
|
|
blah.b.a = 2;
|
|
blah.b.b = 3;
|
|
test(blah);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("struct_passing 3",
|
|
"""
|
|
|
|
typedef struct {long int a; int b[10];} struct_1;
|
|
typedef struct {long int a; struct_1 b;} mystruct;
|
|
|
|
void test(mystruct my){
|
|
assert(my.a == 1);
|
|
assert(my.b.a == 2);
|
|
assert(my.b.b[0] == 3);
|
|
}
|
|
|
|
void main(){
|
|
mystruct blah;
|
|
blah.a = 1;
|
|
blah.b.a = 2;
|
|
blah.b.b[0] = 3;
|
|
test(blah);
|
|
}
|
|
"""
|
|
)
|
|
|
|
#test("struct_return 1",
|
|
#"""
|
|
#
|
|
#typedef struct {long int a; int b;} struct_1;
|
|
#
|
|
#struct_1 test(){
|
|
# struct_1 my;
|
|
# my.a = 1;
|
|
# my.b = 2;
|
|
# return my;
|
|
#}
|
|
#
|
|
#void main(){
|
|
# struct_1 blah;
|
|
# blah = test();
|
|
# assert(blah.a == 1);
|
|
# assert(blah.b == 2);
|
|
#}
|
|
#"""
|
|
#)
|
|
|
|
test("print 1",
|
|
"""
|
|
unsigned test[] = "Hello World!";
|
|
unsigned i=0;
|
|
void stdout_put_char(unsigned value){
|
|
assert(test[i] == value);
|
|
i++;
|
|
}
|
|
#include
|
|
|
|
void main(){
|
|
print_string("Hello World!");
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("print 2",
|
|
"""
|
|
unsigned test[] = "12345";
|
|
unsigned i=0;
|
|
void stdout_put_char(unsigned value){
|
|
assert(test[i] == value);
|
|
i++;
|
|
}
|
|
#include
|
|
|
|
void main(){
|
|
print_decimal(12345);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("print 3",
|
|
"""
|
|
unsigned test[] = "-1234";
|
|
unsigned i=0;
|
|
void stdout_put_char(unsigned value){
|
|
assert(test[i] == value);
|
|
i++;
|
|
}
|
|
#include
|
|
|
|
void main(){
|
|
print_decimal(-1234);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("print 4",
|
|
"""
|
|
unsigned test[] = "-1";
|
|
unsigned i=0;
|
|
void stdout_put_char(unsigned value){
|
|
assert(test[i] == value);
|
|
i++;
|
|
}
|
|
#include
|
|
|
|
void main(){
|
|
print_decimal(-1);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("print 5",
|
|
"""
|
|
unsigned test[] = "7fff";
|
|
unsigned i=0;
|
|
void stdout_put_char(unsigned value){
|
|
assert(test[i] == value);
|
|
i++;
|
|
}
|
|
#include
|
|
|
|
void main(){
|
|
print_hex(0x7fff);
|
|
}
|
|
"""
|
|
)
|
|
|
|
test("print 6",
|
|
"""
|
|
unsigned test[] = "ffff";
|
|
unsigned i=0;
|
|
void stdout_put_char(unsigned value){
|
|
assert(test[i] == value);
|
|
i++;
|
|
}
|
|
#include
|
|
|
|
void main(){
|
|
print_uhex(0xffffu);
|
|
}
|
|
"""
|
|
)
|
|
|
test("unsigned divide 1",
|
test("unsigned divide 1",
|
"""
|
"""
|
void main(){
|
void main(){
|
unsigned a = 10;
|
unsigned a = 10;
|
unsigned b = 5;
|
unsigned b = 5;
|
assert(a/b==2);
|
assert(a/b==2);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("long unsigned divide 1",
|
test("long unsigned divide 1",
|
"""
|
"""
|
void main(){
|
void main(){
|
long unsigned a = 1000000L;
|
long unsigned a = 1000000L;
|
long unsigned b = 500000L;
|
long unsigned b = 500000L;
|
assert(a/b==2);
|
assert(a/b==2);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("divide 1",
|
test("divide 1",
|
"""
|
"""
|
void main(){
|
void main(){
|
int a = 10;
|
int a = 10;
|
int b = 5;
|
int b = 5;
|
assert(a/b==2);
|
assert(a/b==2);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("long divide 1",
|
test("long divide 1",
|
"""
|
"""
|
void main(){
|
void main(){
|
long a = 1000000L;
|
long a = 1000000L;
|
long b = 500000L;
|
long b = 500000L;
|
assert(a/b==2);
|
assert(a/b==2);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("long 1",
|
test("long 1",
|
"""
|
"""
|
void main(){
|
void main(){
|
long a = 100000L;
|
long a = 100000L;
|
assert(a==100000L);
|
assert(a==100000L);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("long 2",
|
test("long 2",
|
"""
|
"""
|
void main(){
|
void main(){
|
long a = 100000L;
|
long a = 100000L;
|
assert(sizeof a == 4);
|
assert(sizeof a == 4);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("long 3",
|
test("long 3",
|
"""
|
"""
|
void main(){
|
void main(){
|
long a = 0xffffL;
|
long a = 0xffffL;
|
assert(a+1 != 0);
|
assert(a+1 != 0);
|
assert(a+1 == 0x10000L);
|
assert(a+1 == 0x10000L);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("long 4",
|
test("long 4",
|
"""
|
"""
|
void main(){
|
void main(){
|
long a = 0xffffL;
|
long a = 0xffffL;
|
long b = 0xffffL;
|
long b = 0xffffL;
|
assert(a+b == 0x1fffeL);
|
assert(a+b == 0x1fffeL);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("long 5",
|
test("long 5",
|
"""
|
"""
|
void main(){
|
void main(){
|
long a = 0xffffffffUL;
|
long a = 0xffffffffUL;
|
long b = 0x0;
|
long b = 0x0;
|
assert(a < b);
|
assert(a < b);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("long 6",
|
test("long 6",
|
"""
|
"""
|
void main(){
|
void main(){
|
unsigned long a = 0xffffffffUL;
|
unsigned long a = 0xffffffffUL;
|
long b = 0x0;
|
long b = 0x0;
|
assert(a > b);
|
assert(a > b);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("long 7",
|
test("long 7",
|
"""
|
"""
|
void test_long(long a){
|
void test_long(long a){
|
assert(a+1 != 0);
|
assert(a+1 != 0);
|
assert(a+1 == 0x10000L);
|
assert(a+1 == 0x10000L);
|
}
|
}
|
|
|
void main(){
|
void main(){
|
long a = 0xffffL;
|
long a = 0xffffL;
|
test_long(a);
|
test_long(a);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("long 8",
|
test("long 8",
|
"""
|
"""
|
void test_long(unsigned long a){
|
void test_long(unsigned long a){
|
assert(a > 0);
|
assert(a > 0);
|
}
|
}
|
|
|
void main(){
|
void main(){
|
unsigned long a = 0xffffffffUL;
|
unsigned long a = 0xffffffffUL;
|
test_long(a);
|
test_long(a);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("long 9",
|
test("long 9",
|
"""
|
"""
|
void test_long(long a){
|
void test_long(long a){
|
assert(a < 0);
|
assert(a < 0);
|
}
|
}
|
|
|
void main(){
|
void main(){
|
unsigned long a = 0xffffffffUL;
|
unsigned long a = 0xffffffffUL;
|
test_long(a);
|
test_long(a);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("long 10",
|
test("long 10",
|
"""
|
"""
|
void test_long(unsigned long a){
|
void test_long(unsigned long a){
|
assert(a > 0);
|
assert(a > 0);
|
}
|
}
|
|
|
void main(){
|
void main(){
|
long a = 0xffffffffUL;
|
long a = 0xffffffffUL;
|
test_long(a);
|
test_long(a);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("long 11",
|
test("long 11",
|
"""
|
"""
|
void main(){
|
void main(){
|
long a[2];
|
long a[2];
|
a[0] = 0xffffffffUL;
|
a[0] = 0xffffffffUL;
|
a[1] = 0xffffffffUL;
|
a[1] = 0xffffffffUL;
|
assert(a[1] == 0xffffffffUL);
|
assert(a[1] == 0xffffffffUL);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("long 12",
|
test("long 12",
|
"""
|
"""
|
void main(){
|
void main(){
|
long a[2];
|
long a[2];
|
int b[2];
|
int b[2];
|
a[0] = 1;
|
a[0] = 1;
|
b[0] = 2;
|
b[0] = 2;
|
a[1] = 3;
|
a[1] = 3;
|
b[1] = 4;
|
b[1] = 4;
|
assert(a[0] == 1);
|
assert(a[0] == 1);
|
assert(b[0] == 2);
|
assert(b[0] == 2);
|
assert(a[1] == 3);
|
assert(a[1] == 3);
|
assert(b[1] == 4);
|
assert(b[1] == 4);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("void 1",
|
test("void 1",
|
"""
|
"""
|
void func(unsigned i){
|
void func(unsigned i){
|
}
|
}
|
void main(){
|
void main(){
|
int a = 1;
|
int a = 1;
|
assert(a++ == 1);
|
assert(a++ == 1);
|
assert(a++ == 2);
|
assert(a++ == 2);
|
assert(a == 3);
|
assert(a == 3);
|
assert(a-- == 3);
|
assert(a-- == 3);
|
assert(a-- == 2);
|
assert(a-- == 2);
|
assert(a == 1);
|
assert(a == 1);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("postfix 1",
|
test("postfix 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
assert(a++ == 1);
|
assert(a++ == 1);
|
assert(a++ == 2);
|
assert(a++ == 2);
|
assert(a == 3);
|
assert(a == 3);
|
assert(a-- == 3);
|
assert(a-- == 3);
|
assert(a-- == 2);
|
assert(a-- == 2);
|
assert(a == 1);
|
assert(a == 1);
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
|
|
test("sizeof 1",
|
test("sizeof 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
unsigned a = 0xffffU;
|
unsigned a = 0xffffU;
|
unsigned b = 0x7fff;
|
unsigned b = 0x7fff;
|
unsigned c[4];
|
unsigned c[4];
|
unsigned d[] = "asdfg";
|
unsigned d[] = "asdfg";
|
assert(sizeof a == 2);
|
assert(sizeof a == 2);
|
assert(sizeof b == 2);
|
assert(sizeof b == 2);
|
assert(sizeof c == 8);
|
assert(sizeof c == 8);
|
assert(sizeof d == 12);
|
assert(sizeof d == 12);
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("type_unsigned 1",
|
test("type_unsigned 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
unsigned a = 0xffffU;
|
unsigned a = 0xffffU;
|
unsigned b = 0x7fff;
|
unsigned b = 0x7fff;
|
assert(a==0xffffU);
|
assert(a==0xffffU);
|
assert(a > b);
|
assert(a > b);
|
|
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("type_unsigned 2",
|
test("type_unsigned 2",
|
"""
|
"""
|
int main(){
|
int main(){
|
unsigned a = 0xffffU;
|
unsigned a = 0xffffU;
|
unsigned b = 0x7fff;
|
unsigned b = 0x7fff;
|
assert(a==0xffffU);
|
assert(a==0xffffU);
|
assert(b < a);
|
assert(b < a);
|
|
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("type_unsigned 3",
|
test("type_unsigned 3",
|
"""
|
"""
|
int test(unsigned a){
|
int test(unsigned a){
|
return a;
|
return a;
|
}
|
}
|
|
|
int main(){
|
int main(){
|
assert(test(3) == 3);
|
assert(test(3) == 3);
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("type_unsigned 4",
|
test("type_unsigned 4",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
unsigned b = 1;
|
unsigned b = 1;
|
assert(a == b);
|
assert(a == b);
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("type_unsigned 5",
|
test("type_unsigned 5",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
assert(a == 1);
|
assert(a == 1);
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("type_unsigned 6",
|
test("type_unsigned 6",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
assert(1 == a);
|
assert(1 == a);
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("type_unsigned 7",
|
test("type_unsigned 7",
|
"""
|
"""
|
int main(){
|
int main(){
|
unsigned b = 1;
|
unsigned b = 1;
|
assert(1 == b);
|
assert(1 == b);
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("type_unsigned 8",
|
test("type_unsigned 8",
|
"""
|
"""
|
int main(){
|
int main(){
|
unsigned b = 1;
|
unsigned b = 1;
|
assert(b == 1);
|
assert(b == 1);
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("type_compatibility 1",
|
test("type_compatibility 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 4;
|
int a = 4;
|
char b = 6;
|
char b = 6;
|
b = a;
|
b = a;
|
assert(b==4);
|
assert(b==4);
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("type_compatibility 2",
|
test("type_compatibility 2",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a[2];
|
int a[2];
|
char b[2];
|
char b[2];
|
b = a;
|
b = a;
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("type_compatibility 3",
|
test("type_compatibility 3",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a[2];
|
int a[2];
|
char b[2];
|
char b[2];
|
a = b;
|
a = b;
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("type_compatibility 4",
|
test("type_compatibility 4",
|
"""
|
"""
|
int main(){
|
int main(){
|
long a[2];
|
long a[2];
|
char b[2];
|
char b[2];
|
a = b;
|
a = b;
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("type_compatibility 5",
|
test("type_compatibility 5",
|
"""
|
"""
|
int main(){
|
int main(){
|
long a[2];
|
long a[2];
|
char b[2];
|
char b[2];
|
a = b;
|
a = b;
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("string 1 a",
|
test("string 1 a",
|
"""
|
"""
|
int main(){
|
int main(){
|
int c[4] = "aA1";
|
int c[4] = "aA1";
|
assert(c[0] == 97);
|
assert(c[0] == 97);
|
assert(c[1] == 65);
|
assert(c[1] == 65);
|
assert(c[2] == 49);
|
assert(c[2] == 49);
|
assert(c[3] == 0);
|
assert(c[3] == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("string 1 b",
|
test("string 1 b",
|
"""
|
"""
|
int main(){
|
int main(){
|
int c[4] = "aA1";
|
int c[4] = "aA1";
|
assert(c[0] == 97);
|
assert(c[0] == 97);
|
assert(c[1] == 65);
|
assert(c[1] == 65);
|
assert(c[2] == 49);
|
assert(c[2] == 49);
|
assert(c[3] == 0);
|
assert(c[3] == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""", True)
|
""", True)
|
|
|
test("string 2a",
|
test("string 2a",
|
"""
|
"""
|
int main(){
|
int main(){
|
int c[] = "aA1";
|
int c[] = "aA1";
|
assert(c[0] == 97);
|
assert(c[0] == 97);
|
assert(c[1] == 65);
|
assert(c[1] == 65);
|
assert(c[2] == 49);
|
assert(c[2] == 49);
|
assert(c[3] == 0);
|
assert(c[3] == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("string 2b",
|
test("string 2b",
|
"""
|
"""
|
int main(){
|
int main(){
|
int c[] = "aA1";
|
int c[] = "aA1";
|
assert(c[0] == 97);
|
assert(c[0] == 97);
|
assert(c[1] == 65);
|
assert(c[1] == 65);
|
assert(c[2] == 49);
|
assert(c[2] == 49);
|
assert(c[3] == 0);
|
assert(c[3] == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""", True)
|
""", True)
|
|
|
test_fails("string 3",
|
test_fails("string 3",
|
"""
|
"""
|
int main(){
|
int main(){
|
int c[];
|
int c[];
|
assert(c[0] == 97);
|
assert(c[0] == 97);
|
assert(c[1] == 65);
|
assert(c[1] == 65);
|
assert(c[2] == 49);
|
assert(c[2] == 49);
|
assert(c[3] == 0);
|
assert(c[3] == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("string 4a",
|
test("string 4a",
|
"""
|
"""
|
int test(char c[]){
|
int test(char c[]){
|
assert(c[0] == 97);
|
assert(c[0] == 97);
|
assert(c[1] == 65);
|
assert(c[1] == 65);
|
assert(c[2] == 49);
|
assert(c[2] == 49);
|
assert(c[3] == 0);
|
assert(c[3] == 0);
|
c[0] = 'b';
|
c[0] = 'b';
|
c[1] = 'B';
|
c[1] = 'B';
|
c[2] = '2';
|
c[2] = '2';
|
c[3] = 0;
|
c[3] = 0;
|
return 0;
|
return 0;
|
}
|
}
|
int main(){
|
int main(){
|
char c[] = "aA1";
|
char c[] = "aA1";
|
assert(c[0] == 97);
|
assert(c[0] == 97);
|
assert(c[1] == 65);
|
assert(c[1] == 65);
|
assert(c[2] == 49);
|
assert(c[2] == 49);
|
assert(c[3] == 0);
|
assert(c[3] == 0);
|
test(c);
|
test(c);
|
assert(c[0] == 'b');
|
assert(c[0] == 'b');
|
assert(c[1] == 'B');
|
assert(c[1] == 'B');
|
assert(c[2] == '2');
|
assert(c[2] == '2');
|
assert(c[3] == 0);
|
assert(c[3] == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("string 4b",
|
test("string 4b",
|
"""
|
"""
|
int test(char c[]){
|
int test(char c[]){
|
assert(c[0] == 97);
|
assert(c[0] == 97);
|
assert(c[1] == 65);
|
assert(c[1] == 65);
|
assert(c[2] == 49);
|
assert(c[2] == 49);
|
assert(c[3] == 0);
|
assert(c[3] == 0);
|
c[0] = 'b';
|
c[0] = 'b';
|
c[1] = 'B';
|
c[1] = 'B';
|
c[2] = '2';
|
c[2] = '2';
|
c[3] = 0;
|
c[3] = 0;
|
return 0;
|
return 0;
|
}
|
}
|
int main(){
|
int main(){
|
char c[] = "aA1";
|
char c[] = "aA1";
|
assert(c[0] == 97);
|
assert(c[0] == 97);
|
assert(c[1] == 65);
|
assert(c[1] == 65);
|
assert(c[2] == 49);
|
assert(c[2] == 49);
|
assert(c[3] == 0);
|
assert(c[3] == 0);
|
test(c);
|
test(c);
|
assert(c[0] == 'b');
|
assert(c[0] == 'b');
|
assert(c[1] == 'B');
|
assert(c[1] == 'B');
|
assert(c[2] == '2');
|
assert(c[2] == '2');
|
assert(c[3] == 0);
|
assert(c[3] == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""", True)
|
""", True)
|
|
|
test_fails("string 5",
|
test_fails("string 5",
|
"""
|
"""
|
int main(){
|
int main(){
|
int c[] "\\n";
|
int c[] "\\n";
|
assert(c[0] == 10);
|
assert(c[0] == 10);
|
assert(c[1] == 0);
|
assert(c[1] == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("string 6a",
|
test("string 6a",
|
"""
|
"""
|
int test(char c[]){
|
int test(char c[]){
|
assert(c[0] == 97);
|
assert(c[0] == 97);
|
assert(c[1] == 65);
|
assert(c[1] == 65);
|
assert(c[2] == 49);
|
assert(c[2] == 49);
|
assert(c[3] == 0);
|
assert(c[3] == 0);
|
return 0;
|
return 0;
|
}
|
}
|
int main(){
|
int main(){
|
test("aA1");
|
test("aA1");
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
|
|
test("string 6b",
|
test("string 6b",
|
"""
|
"""
|
int test(char c[]){
|
int test(char c[]){
|
assert(c[0] == 97);
|
assert(c[0] == 97);
|
assert(c[1] == 65);
|
assert(c[1] == 65);
|
assert(c[2] == 49);
|
assert(c[2] == 49);
|
assert(c[3] == 0);
|
assert(c[3] == 0);
|
return 0;
|
return 0;
|
}
|
}
|
int main(){
|
int main(){
|
test("aA1");
|
test("aA1");
|
return 0;
|
return 0;
|
}
|
}
|
""", True)
|
""", True)
|
|
|
test("string 7a",
|
test("string 7a",
|
"""
|
"""
|
int main(){
|
int main(){
|
char c[] = "a\\n";
|
char c[] = "a\\n";
|
assert(c[0] == 97);
|
assert(c[0] == 97);
|
assert(c[1] == 10);
|
assert(c[1] == 10);
|
assert(c[2] == 0);
|
assert(c[2] == 0);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
|
|
test("string 7b",
|
test("string 7b",
|
"""
|
"""
|
int main(){
|
int main(){
|
char c[] = "a\\n";
|
char c[] = "a\\n";
|
assert(c[0] == 97);
|
assert(c[0] == 97);
|
assert(c[1] == 10);
|
assert(c[1] == 10);
|
assert(c[2] == 0);
|
assert(c[2] == 0);
|
return 0;
|
return 0;
|
}
|
}
|
""", True)
|
""", True)
|
|
|
test("char 1",
|
test("char 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
int c = 'a';
|
int c = 'a';
|
assert(c == 97);
|
assert(c == 97);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("char 2",
|
test("char 2",
|
"""
|
"""
|
int main(){
|
int main(){
|
int c = 'A';
|
int c = 'A';
|
assert(c == 65);
|
assert(c == 65);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("char 3",
|
test("char 3",
|
"""
|
"""
|
int main(){
|
int main(){
|
int c = '1';
|
int c = '1';
|
assert(c == 49);
|
assert(c == 49);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("char 4",
|
test("char 4",
|
"""
|
"""
|
int main(){
|
int main(){
|
int c = '\\n';
|
int c = '\\n';
|
assert(c == 10);
|
assert(c == 10);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned long modulo 1",
|
test("unsigned long modulo 1",
|
"""
|
"""
|
unsigned long int main(){
|
unsigned long int main(){
|
unsigned long int a = 3;
|
unsigned long int a = 3;
|
unsigned long int b = 4;
|
unsigned long int b = 4;
|
assert(a%b == 3);
|
assert(a%b == 3);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned long modulo 3",
|
test("unsigned long modulo 3",
|
"""
|
"""
|
unsigned long int main(){
|
unsigned long int main(){
|
unsigned long int a = 7;
|
unsigned long int a = 7;
|
unsigned long int b = 8;
|
unsigned long int b = 8;
|
assert(a%b == 7);
|
assert(a%b == 7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned long modulo 4",
|
test("unsigned long modulo 4",
|
"""
|
"""
|
unsigned long int main(){
|
unsigned long int main(){
|
unsigned long int a = 15;
|
unsigned long int a = 15;
|
unsigned long int b = 8;
|
unsigned long int b = 8;
|
assert(a%b == 7);
|
assert(a%b == 7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned long modulo 9",
|
test("unsigned long modulo 9",
|
"""
|
"""
|
unsigned long int main(){
|
unsigned long int main(){
|
unsigned long int a = 32766;
|
unsigned long int a = 32766;
|
unsigned long int b = 0;
|
unsigned long int b = 0;
|
assert(a%b == 32766);
|
assert(a%b == 32766);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned long division 1",
|
test("unsigned long division 1",
|
"""
|
"""
|
unsigned long int main(){
|
unsigned long int main(){
|
unsigned long int a = 15;
|
unsigned long int a = 15;
|
unsigned long int b = 3;
|
unsigned long int b = 3;
|
assert(a/b == 5);
|
assert(a/b == 5);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
|
|
test("unsigned long division 2",
|
test("unsigned long division 2",
|
"""
|
"""
|
unsigned long int main(){
|
unsigned long int main(){
|
unsigned long int a = 12;
|
unsigned long int a = 12;
|
unsigned long int b = 4;
|
unsigned long int b = 4;
|
assert(a/b == 3);
|
assert(a/b == 3);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned long division 3",
|
test("unsigned long division 3",
|
"""
|
"""
|
unsigned long int main(){
|
unsigned long int main(){
|
unsigned long int a = 1;
|
unsigned long int a = 1;
|
unsigned long int b = 1;
|
unsigned long int b = 1;
|
assert(a/b == 1);
|
assert(a/b == 1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned long division 6",
|
test("unsigned long division 6",
|
"""
|
"""
|
unsigned long int main(){
|
unsigned long int main(){
|
unsigned long int a = 0;
|
unsigned long int a = 0;
|
unsigned long int b = 1;
|
unsigned long int b = 1;
|
assert(a/b == 0);
|
assert(a/b == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned long division 7",
|
test("unsigned long division 7",
|
"""
|
"""
|
unsigned long int main(){
|
unsigned long int main(){
|
unsigned long int a = 5;
|
unsigned long int a = 5;
|
unsigned long int b = 2;
|
unsigned long int b = 2;
|
assert(a/b == 2);
|
assert(a/b == 2);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned long division 9",
|
test("unsigned long division 9",
|
"""
|
"""
|
unsigned long int main(){
|
unsigned long int main(){
|
unsigned long int a = 0;
|
unsigned long int a = 0;
|
unsigned long int b = 32767;
|
unsigned long int b = 32767;
|
assert(a/b == 0);
|
assert(a/b == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned long division 10",
|
test("unsigned long division 10",
|
"""
|
"""
|
unsigned long int main(){
|
unsigned long int main(){
|
unsigned long int a = 32767;
|
unsigned long int a = 32767;
|
unsigned long int b = 1;
|
unsigned long int b = 1;
|
assert(a/b == 32767);
|
assert(a/b == 32767);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned long division 11",
|
test("unsigned long division 11",
|
"""
|
"""
|
unsigned long int main(){
|
unsigned long int main(){
|
unsigned long int a = 32767;
|
unsigned long int a = 32767;
|
unsigned long int b = 2;
|
unsigned long int b = 2;
|
assert(a/b == 16383);
|
assert(a/b == 16383);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned long division 12",
|
test("unsigned long division 12",
|
"""
|
"""
|
unsigned long int main(){
|
unsigned long int main(){
|
unsigned long int a = 32767;
|
unsigned long int a = 32767;
|
unsigned long int b = 32767;
|
unsigned long int b = 32767;
|
assert(a/b == 1);
|
assert(a/b == 1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned modulo 1",
|
test("unsigned modulo 1",
|
"""
|
"""
|
unsigned int main(){
|
unsigned int main(){
|
unsigned int a = 3;
|
unsigned int a = 3;
|
unsigned int b = 4;
|
unsigned int b = 4;
|
assert(a%b == 3);
|
assert(a%b == 3);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned modulo 3",
|
test("unsigned modulo 3",
|
"""
|
"""
|
unsigned int main(){
|
unsigned int main(){
|
unsigned int a = 7;
|
unsigned int a = 7;
|
unsigned int b = 8;
|
unsigned int b = 8;
|
assert(a%b == 7);
|
assert(a%b == 7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned modulo 4",
|
test("unsigned modulo 4",
|
"""
|
"""
|
unsigned int main(){
|
unsigned int main(){
|
unsigned int a = 15;
|
unsigned int a = 15;
|
unsigned int b = 8;
|
unsigned int b = 8;
|
assert(a%b == 7);
|
assert(a%b == 7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned modulo 9",
|
test("unsigned modulo 9",
|
"""
|
"""
|
unsigned int main(){
|
unsigned int main(){
|
unsigned int a = 32766;
|
unsigned int a = 32766;
|
unsigned int b = 0;
|
unsigned int b = 0;
|
assert(a%b == 32766);
|
assert(a%b == 32766);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned division 1",
|
test("unsigned division 1",
|
"""
|
"""
|
unsigned int main(){
|
unsigned int main(){
|
unsigned int a = 15;
|
unsigned int a = 15;
|
unsigned int b = 3;
|
unsigned int b = 3;
|
assert(a/b == 5);
|
assert(a/b == 5);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
|
|
test("unsigned division 2",
|
test("unsigned division 2",
|
"""
|
"""
|
unsigned int main(){
|
unsigned int main(){
|
unsigned int a = 12;
|
unsigned int a = 12;
|
unsigned int b = 4;
|
unsigned int b = 4;
|
assert(a/b == 3);
|
assert(a/b == 3);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned division 3",
|
test("unsigned division 3",
|
"""
|
"""
|
unsigned int main(){
|
unsigned int main(){
|
unsigned int a = 1;
|
unsigned int a = 1;
|
unsigned int b = 1;
|
unsigned int b = 1;
|
assert(a/b == 1);
|
assert(a/b == 1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned division 6",
|
test("unsigned division 6",
|
"""
|
"""
|
unsigned int main(){
|
unsigned int main(){
|
unsigned int a = 0;
|
unsigned int a = 0;
|
unsigned int b = 1;
|
unsigned int b = 1;
|
assert(a/b == 0);
|
assert(a/b == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned division 7",
|
test("unsigned division 7",
|
"""
|
"""
|
unsigned int main(){
|
unsigned int main(){
|
unsigned int a = 5;
|
unsigned int a = 5;
|
unsigned int b = 2;
|
unsigned int b = 2;
|
assert(a/b == 2);
|
assert(a/b == 2);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned division 9",
|
test("unsigned division 9",
|
"""
|
"""
|
unsigned int main(){
|
unsigned int main(){
|
unsigned int a = 0;
|
unsigned int a = 0;
|
unsigned int b = 32767;
|
unsigned int b = 32767;
|
assert(a/b == 0);
|
assert(a/b == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned division 10",
|
test("unsigned division 10",
|
"""
|
"""
|
unsigned int main(){
|
unsigned int main(){
|
unsigned int a = 32767;
|
unsigned int a = 32767;
|
unsigned int b = 1;
|
unsigned int b = 1;
|
assert(a/b == 32767);
|
assert(a/b == 32767);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned division 11",
|
test("unsigned division 11",
|
"""
|
"""
|
unsigned int main(){
|
unsigned int main(){
|
unsigned int a = 32767;
|
unsigned int a = 32767;
|
unsigned int b = 2;
|
unsigned int b = 2;
|
assert(a/b == 16383);
|
assert(a/b == 16383);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("unsigned division 12",
|
test("unsigned division 12",
|
"""
|
"""
|
unsigned int main(){
|
unsigned int main(){
|
unsigned int a = 32767;
|
unsigned int a = 32767;
|
unsigned int b = 32767;
|
unsigned int b = 32767;
|
assert(a/b == 1);
|
assert(a/b == 1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long modulo 1",
|
test("long modulo 1",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = 3;
|
long int a = 3;
|
long int b = 4;
|
long int b = 4;
|
assert(a%b == 3);
|
assert(a%b == 3);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long modulo 2",
|
test("long modulo 2",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = -3;
|
long int a = -3;
|
long int b = 4;
|
long int b = 4;
|
assert(a%b == -3);
|
assert(a%b == -3);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long modulo 3",
|
test("long modulo 3",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = 7;
|
long int a = 7;
|
long int b = 8;
|
long int b = 8;
|
assert(a%b == 7);
|
assert(a%b == 7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long modulo 4",
|
test("long modulo 4",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = 15;
|
long int a = 15;
|
long int b = 8;
|
long int b = 8;
|
assert(a%b == 7);
|
assert(a%b == 7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long modulo 5",
|
test("long modulo 5",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = -7;
|
long int a = -7;
|
long int b = 8;
|
long int b = 8;
|
assert(a%b == -7);
|
assert(a%b == -7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long modulo 6",
|
test("long modulo 6",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = -15;
|
long int a = -15;
|
long int b = 8;
|
long int b = 8;
|
assert(a%b == -7);
|
assert(a%b == -7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long modulo 7",
|
test("long modulo 7",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = 7;
|
long int a = 7;
|
long int b = -8;
|
long int b = -8;
|
assert(a%b == 7);
|
assert(a%b == 7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long modulo 8",
|
test("long modulo 8",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = 15;
|
long int a = 15;
|
long int b = -8;
|
long int b = -8;
|
assert(a%b == 7);
|
assert(a%b == 7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long modulo 9",
|
test("long modulo 9",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = 32766;
|
long int a = 32766;
|
long int b = 0;
|
long int b = 0;
|
assert(a%b == 32766);
|
assert(a%b == 32766);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long division 1",
|
test("long division 1",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = 15;
|
long int a = 15;
|
long int b = 3;
|
long int b = 3;
|
assert(a/b == 5);
|
assert(a/b == 5);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
|
|
test("long division 2",
|
test("long division 2",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = 12;
|
long int a = 12;
|
long int b = 4;
|
long int b = 4;
|
assert(a/b == 3);
|
assert(a/b == 3);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long division 3",
|
test("long division 3",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = 1;
|
long int a = 1;
|
long int b = 1;
|
long int b = 1;
|
assert(a/b == 1);
|
assert(a/b == 1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long division 4",
|
test("long division 4",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = 1;
|
long int a = 1;
|
long int b = -1;
|
long int b = -1;
|
assert(a/b == -1);
|
assert(a/b == -1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long division 5",
|
test("long division 5",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = -1;
|
long int a = -1;
|
long int b = 1;
|
long int b = 1;
|
assert(a/b == -1);
|
assert(a/b == -1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long division 6",
|
test("long division 6",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = 0;
|
long int a = 0;
|
long int b = 1;
|
long int b = 1;
|
assert(a/b == 0);
|
assert(a/b == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long division 7",
|
test("long division 7",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = 5;
|
long int a = 5;
|
long int b = 2;
|
long int b = 2;
|
assert(a/b == 2);
|
assert(a/b == 2);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long division 8",
|
test("long division 8",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = -5;
|
long int a = -5;
|
long int b = 2;
|
long int b = 2;
|
assert(a/b == -2);
|
assert(a/b == -2);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long division 9",
|
test("long division 9",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = 0;
|
long int a = 0;
|
long int b = 32767;
|
long int b = 32767;
|
assert(a/b == 0);
|
assert(a/b == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long division 10",
|
test("long division 10",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = 32767;
|
long int a = 32767;
|
long int b = 1;
|
long int b = 1;
|
assert(a/b == 32767);
|
assert(a/b == 32767);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long division 11",
|
test("long division 11",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = 32767;
|
long int a = 32767;
|
long int b = 2;
|
long int b = 2;
|
assert(a/b == 16383);
|
assert(a/b == 16383);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long division 12",
|
test("long division 12",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = 32767;
|
long int a = 32767;
|
long int b = 32767;
|
long int b = 32767;
|
assert(a/b == 1);
|
assert(a/b == 1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long division 13",
|
test("long division 13",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = -32767-1;
|
long int a = -32767-1;
|
long int b = -32767-1;
|
long int b = -32767-1;
|
assert(a/b == 1);
|
assert(a/b == 1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("long division 14",
|
test("long division 14",
|
"""
|
"""
|
long int main(){
|
long int main(){
|
long int a = -32767;
|
long int a = -32767;
|
long int b = -1;
|
long int b = -1;
|
assert(a/b == 32767);
|
assert(a/b == 32767);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("modulo 1",
|
test("modulo 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 3;
|
int a = 3;
|
int b = 4;
|
int b = 4;
|
assert(a%b == 3);
|
assert(a%b == 3);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("modulo 2",
|
test("modulo 2",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = -3;
|
int a = -3;
|
int b = 4;
|
int b = 4;
|
assert(a%b == -3);
|
assert(a%b == -3);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("modulo 3",
|
test("modulo 3",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 7;
|
int a = 7;
|
int b = 8;
|
int b = 8;
|
assert(a%b == 7);
|
assert(a%b == 7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("modulo 4",
|
test("modulo 4",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 15;
|
int a = 15;
|
int b = 8;
|
int b = 8;
|
assert(a%b == 7);
|
assert(a%b == 7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("modulo 5",
|
test("modulo 5",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = -7;
|
int a = -7;
|
int b = 8;
|
int b = 8;
|
assert(a%b == -7);
|
assert(a%b == -7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("modulo 6",
|
test("modulo 6",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = -15;
|
int a = -15;
|
int b = 8;
|
int b = 8;
|
assert(a%b == -7);
|
assert(a%b == -7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("modulo 7",
|
test("modulo 7",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 7;
|
int a = 7;
|
int b = -8;
|
int b = -8;
|
assert(a%b == 7);
|
assert(a%b == 7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("modulo 8",
|
test("modulo 8",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 15;
|
int a = 15;
|
int b = -8;
|
int b = -8;
|
assert(a%b == 7);
|
assert(a%b == 7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("modulo 9",
|
test("modulo 9",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 32766;
|
int a = 32766;
|
int b = 0;
|
int b = 0;
|
assert(a%b == 32766);
|
assert(a%b == 32766);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("division 1",
|
test("division 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 15;
|
int a = 15;
|
int b = 3;
|
int b = 3;
|
assert(a/b == 5);
|
assert(a/b == 5);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
|
|
test("division 2",
|
test("division 2",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 12;
|
int a = 12;
|
int b = 4;
|
int b = 4;
|
assert(a/b == 3);
|
assert(a/b == 3);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("division 3",
|
test("division 3",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
int b = 1;
|
int b = 1;
|
assert(a/b == 1);
|
assert(a/b == 1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("division 4",
|
test("division 4",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
int b = -1;
|
int b = -1;
|
assert(a/b == -1);
|
assert(a/b == -1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("division 5",
|
test("division 5",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = -1;
|
int a = -1;
|
int b = 1;
|
int b = 1;
|
assert(a/b == -1);
|
assert(a/b == -1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("division 6",
|
test("division 6",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 0;
|
int a = 0;
|
int b = 1;
|
int b = 1;
|
assert(a/b == 0);
|
assert(a/b == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("division 7",
|
test("division 7",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 5;
|
int a = 5;
|
int b = 2;
|
int b = 2;
|
assert(a/b == 2);
|
assert(a/b == 2);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("division 8",
|
test("division 8",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = -5;
|
int a = -5;
|
int b = 2;
|
int b = 2;
|
assert(a/b == -2);
|
assert(a/b == -2);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("division 9",
|
test("division 9",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 0;
|
int a = 0;
|
int b = 32767;
|
int b = 32767;
|
assert(a/b == 0);
|
assert(a/b == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("division 10",
|
test("division 10",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 32767;
|
int a = 32767;
|
int b = 1;
|
int b = 1;
|
assert(a/b == 32767);
|
assert(a/b == 32767);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("division 11",
|
test("division 11",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 32767;
|
int a = 32767;
|
int b = 2;
|
int b = 2;
|
assert(a/b == 16383);
|
assert(a/b == 16383);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("division 12",
|
test("division 12",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 32767;
|
int a = 32767;
|
int b = 32767;
|
int b = 32767;
|
assert(a/b == 1);
|
assert(a/b == 1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("division 13",
|
test("division 13",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = -32767-1;
|
int a = -32767-1;
|
int b = -32767-1;
|
int b = -32767-1;
|
assert(a/b == 1);
|
assert(a/b == 1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("division 14",
|
test("division 14",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = -32767;
|
int a = -32767;
|
int b = -1;
|
int b = -1;
|
assert(a/b == 32767);
|
assert(a/b == 32767);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("struct with array 1",
|
test("struct with array 1",
|
"""
|
"""
|
typedef struct {int a; int b; int c[2];} blah;
|
typedef struct {int a; int b; int c[2];} blah;
|
blah myblah;
|
blah myblah;
|
|
|
void test(){
|
void test(){
|
assert(myblah.a == 1);
|
assert(myblah.a == 1);
|
assert(myblah.b == 2);
|
assert(myblah.b == 2);
|
assert(myblah.c[0] == 3);
|
assert(myblah.c[0] == 3);
|
assert(myblah.c[1] == 4);
|
assert(myblah.c[1] == 4);
|
myblah.a = 5;
|
myblah.a = 5;
|
myblah.b = 6;
|
myblah.b = 6;
|
myblah.c[0] = 7;
|
myblah.c[0] = 7;
|
myblah.c[1] = 8;
|
myblah.c[1] = 8;
|
}
|
}
|
|
|
void main(){
|
void main(){
|
myblah.a = 1;
|
myblah.a = 1;
|
myblah.b = 2;
|
myblah.b = 2;
|
myblah.c[0] = 3;
|
myblah.c[0] = 3;
|
myblah.c[1] = 4;
|
myblah.c[1] = 4;
|
test();
|
test();
|
assert(myblah.a == 5);
|
assert(myblah.a == 5);
|
assert(myblah.b == 6);
|
assert(myblah.b == 6);
|
assert(myblah.c[0] == 7);
|
assert(myblah.c[0] == 7);
|
assert(myblah.c[1] == 8);
|
assert(myblah.c[1] == 8);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("global variables 1",
|
test("global variables 1",
|
"""
|
"""
|
int a;
|
int a;
|
|
|
void test(){
|
void test(){
|
assert(a==12);
|
assert(a==12);
|
a = 24;
|
a = 24;
|
}
|
}
|
|
|
void main(){
|
void main(){
|
a = 12;
|
a = 12;
|
test();
|
test();
|
assert(a==24);
|
assert(a==24);
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test("global variables 2",
|
test("global variables 2",
|
"""
|
"""
|
int a[10];
|
int a[10];
|
|
|
void test(){
|
void test(){
|
assert(a[0] == 0);
|
assert(a[0] == 0);
|
assert(a[1] == 1);
|
assert(a[1] == 1);
|
assert(a[2] == 2);
|
assert(a[2] == 2);
|
assert(a[3] == 3);
|
assert(a[3] == 3);
|
a[0] = 4;
|
a[0] = 4;
|
a[1] = 5;
|
a[1] = 5;
|
a[2] = 6;
|
a[2] = 6;
|
a[3] = 7;
|
a[3] = 7;
|
}
|
}
|
|
|
void main(){
|
void main(){
|
a[0] = 0;
|
a[0] = 0;
|
a[1] = 1;
|
a[1] = 1;
|
a[2] = 2;
|
a[2] = 2;
|
a[3] = 3;
|
a[3] = 3;
|
test();
|
test();
|
assert(a[0] == 4);
|
assert(a[0] == 4);
|
assert(a[1] == 5);
|
assert(a[1] == 5);
|
assert(a[2] == 6);
|
assert(a[2] == 6);
|
assert(a[3] == 7);
|
assert(a[3] == 7);
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test("global variables 3",
|
test("global variables 3",
|
"""
|
"""
|
int a=0, b=1, c=2;
|
int a=0, b=1, c=2;
|
|
|
void test(){
|
void test(){
|
assert(a == 3);
|
assert(a == 3);
|
assert(b == 4);
|
assert(b == 4);
|
assert(c == 5);
|
assert(c == 5);
|
a=6;
|
a=6;
|
b=7;
|
b=7;
|
c=8;
|
c=8;
|
}
|
}
|
|
|
void main(){
|
void main(){
|
assert(a == 0);
|
assert(a == 0);
|
assert(b == 1);
|
assert(b == 1);
|
assert(c == 2);
|
assert(c == 2);
|
a=3;
|
a=3;
|
b=4;
|
b=4;
|
c=5;
|
c=5;
|
test();
|
test();
|
assert(a == 6);
|
assert(a == 6);
|
assert(b == 7);
|
assert(b == 7);
|
assert(c == 8);
|
assert(c == 8);
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test("global variables 4",
|
test("global variables 4",
|
"""
|
"""
|
typedef struct {int a; int b; int c;} blah;
|
typedef struct {int a; int b; int c;} blah;
|
blah myblah;
|
blah myblah;
|
|
|
void test(){
|
void test(){
|
assert(myblah.a == 1);
|
assert(myblah.a == 1);
|
assert(myblah.b == 2);
|
assert(myblah.b == 2);
|
assert(myblah.c == 3);
|
assert(myblah.c == 3);
|
myblah.a = 4;
|
myblah.a = 4;
|
myblah.b = 5;
|
myblah.b = 5;
|
myblah.c = 6;
|
myblah.c = 6;
|
}
|
}
|
|
|
void main(){
|
void main(){
|
myblah.a = 1;
|
myblah.a = 1;
|
myblah.b = 2;
|
myblah.b = 2;
|
myblah.c = 3;
|
myblah.c = 3;
|
test();
|
test();
|
assert(myblah.a == 4);
|
assert(myblah.a == 4);
|
assert(myblah.b == 5);
|
assert(myblah.b == 5);
|
assert(myblah.c == 6);
|
assert(myblah.c == 6);
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("void functions 1",
|
test("void functions 1",
|
"""
|
"""
|
void main(){
|
void main(){
|
int a;
|
int a;
|
int b;
|
int b;
|
b = a;
|
b = a;
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test("void functions 2",
|
test("void functions 2",
|
"""
|
"""
|
void test(){
|
void test(){
|
return;
|
return;
|
}
|
}
|
|
|
void main(){
|
void main(){
|
test();
|
test();
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test_fails("void functions 3",
|
test_fails("void functions 3",
|
"""
|
"""
|
void test(){
|
void test(){
|
return;
|
return;
|
}
|
}
|
|
|
void main(){
|
void main(){
|
int a;
|
int a;
|
a = test();
|
a = test();
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test_fails("void functions 4",
|
test_fails("void functions 4",
|
"""
|
"""
|
void test(){
|
void test(){
|
return 10;
|
return 10;
|
}
|
}
|
|
|
void main(){
|
void main(){
|
int a;
|
int a;
|
a = test();
|
a = test();
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test_fails("type_checking 1",
|
test_fails("type_checking 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a[4];
|
int a[4];
|
int b;
|
int b;
|
b = a;
|
b = a;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test_fails("type_checking 2",
|
test_fails("type_checking 2",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a[4];
|
int a[4];
|
int b[4];
|
int b[4];
|
b[a]=12;
|
b[a]=12;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test_fails("type_checking 3",
|
test_fails("type_checking 3",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a[4];
|
int a[4];
|
int b;
|
int b;
|
if(a) b=12;
|
if(a) b=12;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test_fails("type_checking 4",
|
test_fails("type_checking 4",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a[4];
|
int a[4];
|
int b;
|
int b;
|
while(a) b=12;
|
while(a) b=12;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test_fails("type_checking 5",
|
test_fails("type_checking 5",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a[4];
|
int a[4];
|
int b;
|
int b;
|
for(;a;) b=12;
|
for(;a;) b=12;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test_fails("type_checking 6",
|
test_fails("type_checking 6",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a[4];
|
int a[4];
|
int b;
|
int b;
|
switch(a){}
|
switch(a){}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test_fails("type_checking 7",
|
test_fails("type_checking 7",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a[4];
|
int a[4];
|
int b;
|
int b;
|
switch(b){case a:b=12;}
|
switch(b){case a:b=12;}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test_fails("type_checking 8",
|
test_fails("type_checking 8",
|
"""
|
"""
|
int test(int a[]){
|
int test(int a[]){
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int main(){
|
int main(){
|
int b;
|
int b;
|
test(b);
|
test(b);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test_fails("type_checking 9",
|
test_fails("type_checking 9",
|
"""
|
"""
|
int test(int a){
|
int test(int a){
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int main(){
|
int main(){
|
int b[4];
|
int b[4];
|
test(b);
|
test(b);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test("array passing 1",
|
test("array passing 1",
|
"""
|
"""
|
|
|
int test(int a[]){
|
int test(int a[]){
|
assert(a[0] == 0);
|
assert(a[0] == 0);
|
assert(a[1] == 1);
|
assert(a[1] == 1);
|
assert(a[2] == 2);
|
assert(a[2] == 2);
|
assert(a[3] == 3);
|
assert(a[3] == 3);
|
a[0] = 4;
|
a[0] = 4;
|
a[1] = 5;
|
a[1] = 5;
|
a[2] = 6;
|
a[2] = 6;
|
a[3] = 7;
|
a[3] = 7;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int main(){
|
int main(){
|
int a[4];
|
int a[4];
|
a[0] = 0;
|
a[0] = 0;
|
a[1] = 1;
|
a[1] = 1;
|
a[2] = 2;
|
a[2] = 2;
|
a[3] = 3;
|
a[3] = 3;
|
test(a);
|
test(a);
|
assert(a[0] == 4);
|
assert(a[0] == 4);
|
assert(a[1] == 5);
|
assert(a[1] == 5);
|
assert(a[2] == 6);
|
assert(a[2] == 6);
|
assert(a[3] == 7);
|
assert(a[3] == 7);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
"""
|
"""
|
)
|
)
|
|
|
test("array passing 2",
|
test("array passing 2",
|
"""
|
"""
|
|
|
int test(int a[]){
|
int test(int a[]){
|
assert(a[0] == 0);
|
assert(a[0] == 0);
|
assert(a[1] == 1);
|
assert(a[1] == 1);
|
assert(a[2] == 2);
|
assert(a[2] == 2);
|
assert(a[3] == 3);
|
assert(a[3] == 3);
|
a[0] = 4;
|
a[0] = 4;
|
a[1] = 5;
|
a[1] = 5;
|
a[2] = 6;
|
a[2] = 6;
|
a[3] = 7;
|
a[3] = 7;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int main(){
|
int main(){
|
int a[4];
|
int a[4];
|
int b[4];
|
int b[4];
|
a[0] = 0;
|
a[0] = 0;
|
a[1] = 1;
|
a[1] = 1;
|
a[2] = 2;
|
a[2] = 2;
|
a[3] = 3;
|
a[3] = 3;
|
b = a;
|
b = a;
|
test(b);
|
test(b);
|
assert(a[0] == 4);
|
assert(a[0] == 4);
|
assert(a[1] == 5);
|
assert(a[1] == 5);
|
assert(a[2] == 6);
|
assert(a[2] == 6);
|
assert(a[3] == 7);
|
assert(a[3] == 7);
|
return 0;
|
return 0;
|
}"""
|
}"""
|
)
|
)
|
|
|
test("struct 1",
|
test("struct 1",
|
"""
|
"""
|
struct blah {int a; int b; int c;};
|
struct blah {int a; int b; int c;};
|
int main(){
|
int main(){
|
struct blah myblah;
|
struct blah myblah;
|
myblah.a = 1;
|
myblah.a = 1;
|
myblah.b = 2;
|
myblah.b = 2;
|
myblah.c = 3;
|
myblah.c = 3;
|
assert(myblah.a == 1);
|
assert(myblah.a == 1);
|
assert(myblah.b == 2);
|
assert(myblah.b == 2);
|
assert(myblah.c == 3);
|
assert(myblah.c == 3);
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("struct 2",
|
test("struct 2",
|
"""
|
"""
|
struct as {int a; int b; int c;};
|
struct as {int a; int b; int c;};
|
int main(){
|
int main(){
|
struct as asa;
|
struct as asa;
|
struct as asb;
|
struct as asb;
|
asa.a = 1;
|
asa.a = 1;
|
asb.a = 3;
|
asb.a = 3;
|
asa.b = 2;
|
asa.b = 2;
|
asb.b = 2;
|
asb.b = 2;
|
asa.c = 3;
|
asa.c = 3;
|
asb.c = 1;
|
asb.c = 1;
|
assert(asa.a == 1);
|
assert(asa.a == 1);
|
assert(asb.a == 3);
|
assert(asb.a == 3);
|
assert(asa.b == 2);
|
assert(asa.b == 2);
|
assert(asb.b == 2);
|
assert(asb.b == 2);
|
assert(asa.c == 3);
|
assert(asa.c == 3);
|
assert(asb.c == 1);
|
assert(asb.c == 1);
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("struct 3",
|
test("struct 3",
|
"""
|
"""
|
typedef struct {int a; int b; int c;} blah;
|
typedef struct {int a; int b; int c;} blah;
|
int main(){
|
int main(){
|
blah myblah;
|
blah myblah;
|
myblah.a = 1;
|
myblah.a = 1;
|
myblah.b = 2;
|
myblah.b = 2;
|
myblah.c = 3;
|
myblah.c = 3;
|
assert(myblah.a == 1);
|
assert(myblah.a == 1);
|
assert(myblah.b == 2);
|
assert(myblah.b == 2);
|
assert(myblah.c == 3);
|
assert(myblah.c == 3);
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("struct 4",
|
test("struct 4",
|
"""
|
"""
|
typedef struct{int a; int b; int c;} mytype;
|
typedef struct{int a; int b; int c;} mytype;
|
typedef struct{mytype a;} othertype;
|
typedef struct{mytype a;} othertype;
|
int main(){
|
int main(){
|
othertype a;
|
othertype a;
|
othertype b;
|
othertype b;
|
a.a.a = 1;
|
a.a.a = 1;
|
b.a.a = 2;
|
b.a.a = 2;
|
a.a.b = 3;
|
a.a.b = 3;
|
b.a.b = 4;
|
b.a.b = 4;
|
a.a.c = 5;
|
a.a.c = 5;
|
b.a.c = 6;
|
b.a.c = 6;
|
assert(a.a.a == 1);
|
assert(a.a.a == 1);
|
assert(b.a.a == 2);
|
assert(b.a.a == 2);
|
assert(a.a.b == 3);
|
assert(a.a.b == 3);
|
assert(b.a.b == 4);
|
assert(b.a.b == 4);
|
assert(a.a.c == 5);
|
assert(a.a.c == 5);
|
assert(b.a.c == 6);
|
assert(b.a.c == 6);
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("include 1",
|
test("include 1",
|
"""#include "test_include.c"
|
"""#include "test_include.c"
|
int main(){
|
int main(){
|
assert(include_function()==12);
|
assert(include_function()==12);
|
return 0;
|
return 0;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("switch 1",
|
test("switch 1",
|
"""int main(){
|
"""int main(){
|
switch(0){
|
switch(0){
|
case 0: return 3;
|
case 0: return 3;
|
case 1: return 2;
|
case 1: return 2;
|
case 2: return 1;
|
case 2: return 1;
|
default: return 0;
|
default: return 0;
|
}
|
}
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("switch 2",
|
test("switch 2",
|
"""int main(){
|
"""int main(){
|
switch(2){
|
switch(2){
|
case 0: return 3;
|
case 0: return 3;
|
case 1: return 2;
|
case 1: return 2;
|
case 2: return 1;
|
case 2: return 1;
|
default: return 0;
|
default: return 0;
|
}
|
}
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("switch 3",
|
test("switch 3",
|
"""int main(){
|
"""int main(){
|
switch(5){
|
switch(5){
|
case 0: return 3;
|
case 0: return 3;
|
case 1: return 2;
|
case 1: return 2;
|
case 2: return 1;
|
case 2: return 1;
|
default: return 0;
|
default: return 0;
|
}
|
}
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("switch 4",
|
test("switch 4",
|
"""int main(){
|
"""int main(){
|
int a = 0;
|
int a = 0;
|
switch(0){
|
switch(0){
|
case 0: a = 1;
|
case 0: a = 1;
|
case 1: a = 2;
|
case 1: a = 2;
|
case 2: a = 3;
|
case 2: a = 3;
|
default: a = 4;
|
default: a = 4;
|
}
|
}
|
return a;
|
return a;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("switch 5",
|
test("switch 5",
|
"""int main(){
|
"""int main(){
|
int a = 0;
|
int a = 0;
|
switch(1){
|
switch(1){
|
case 0: a = 1;
|
case 0: a = 1;
|
case 1: a = 2;
|
case 1: a = 2;
|
case 2: a = 3;
|
case 2: a = 3;
|
default: a = 4;
|
default: a = 4;
|
}
|
}
|
return a;
|
return a;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("switch 6",
|
test("switch 6",
|
"""int main(){
|
"""int main(){
|
int a = 1;
|
int a = 1;
|
switch(10){
|
switch(10){
|
case 0: a = 1;
|
case 0: a = 1;
|
case 1: a = 2;
|
case 1: a = 2;
|
case 2: a = 3;
|
case 2: a = 3;
|
default: a = 4;
|
default: a = 4;
|
}
|
}
|
return a;
|
return a;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("switch 7",
|
test("switch 7",
|
"""int main(){
|
"""int main(){
|
int a = 1;
|
int a = 1;
|
switch(0){
|
switch(0){
|
case 0: a = 1; break;
|
case 0: a = 1; break;
|
case 1: a = 2; break;
|
case 1: a = 2; break;
|
case 2: a = 3; break;
|
case 2: a = 3; break;
|
default: a = 4; break;
|
default: a = 4; break;
|
}
|
}
|
return a;
|
return a;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("switch 8",
|
test("switch 8",
|
"""int main(){
|
"""int main(){
|
int a = 1;
|
int a = 1;
|
switch(2){
|
switch(2){
|
case 0: a = 1; break;
|
case 0: a = 1; break;
|
case 1: a = 2; break;
|
case 1: a = 2; break;
|
case 2: a = 3; break;
|
case 2: a = 3; break;
|
default: a = 4; break;
|
default: a = 4; break;
|
}
|
}
|
return a;
|
return a;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
test("switch 9",
|
test("switch 9",
|
"""int main(){
|
"""int main(){
|
int a = 1;
|
int a = 1;
|
switch(9){
|
switch(9){
|
case 0: a = 1; break;
|
case 0: a = 1; break;
|
case 1: a = 2; break;
|
case 1: a = 2; break;
|
case 2: a = 3; break;
|
case 2: a = 3; break;
|
default: a = 4; break;
|
default: a = 4; break;
|
}
|
}
|
return a;
|
return a;
|
}
|
}
|
"""
|
"""
|
)
|
)
|
|
|
test("break 0",
|
test("break 0",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a;
|
int a;
|
while(1){
|
while(1){
|
break;
|
break;
|
assert(0);
|
assert(0);
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("break 1",
|
test("break 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a;
|
int a;
|
for(a=0; a<20; a++){
|
for(a=0; a<20; a++){
|
if(a == 10){
|
if(a == 10){
|
break;
|
break;
|
}
|
}
|
}
|
}
|
assert(a == 10);
|
assert(a == 10);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("continue 0",
|
test("continue 0",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a;
|
int a;
|
for(a=1; a<=10; a++){
|
for(a=1; a<=10; a++){
|
if(a <= 5){
|
if(a <= 5){
|
continue;
|
continue;
|
}
|
}
|
assert(a > 5);
|
assert(a > 5);
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("ternary 0",
|
test("ternary 0",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a;
|
int a;
|
int b=2;
|
int b=2;
|
int c=3;
|
int c=3;
|
assert((1?2:3) == 2);
|
assert((1?2:3) == 2);
|
assert((0?2:3) == 3);
|
assert((0?2:3) == 3);
|
a = 1;
|
a = 1;
|
assert((a?b:c) == 2);
|
assert((a?b:c) == 2);
|
a = 0;
|
a = 0;
|
assert((a?b:c) == 3);
|
assert((a?b:c) == 3);
|
assert((1?b:c) == 2);
|
assert((1?b:c) == 2);
|
assert((0?b:c) == 3);
|
assert((0?b:c) == 3);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("inplace 0",
|
test("inplace 0",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
a += 1;
|
a += 1;
|
assert(a == 2);
|
assert(a == 2);
|
a -= 1;
|
a -= 1;
|
assert(a == 1);
|
assert(a == 1);
|
a *= 2;
|
a *= 2;
|
assert(a == 2);
|
assert(a == 2);
|
a /= 2;
|
a /= 2;
|
assert(a == 1);
|
assert(a == 1);
|
a |= 2;
|
a |= 2;
|
assert(a == 3);
|
assert(a == 3);
|
a &= 2;
|
a &= 2;
|
assert(a == 2);
|
assert(a == 2);
|
a <<= 1;
|
a <<= 1;
|
assert(a == 4);
|
assert(a == 4);
|
a >>= 1;
|
a >>= 1;
|
assert(a == 2);
|
assert(a == 2);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("inplace 1",
|
test("inplace 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a[100];
|
int a[100];
|
a[0] = 1;
|
a[0] = 1;
|
a[20] = 1;
|
a[20] = 1;
|
a[20] += 1;
|
a[20] += 1;
|
assert(a[20] == 2);
|
assert(a[20] == 2);
|
a[20] -= 1;
|
a[20] -= 1;
|
assert(a[20] == 1);
|
assert(a[20] == 1);
|
a[20] *= 2;
|
a[20] *= 2;
|
assert(a[20] == 2);
|
assert(a[20] == 2);
|
a[20] /= 2;
|
a[20] /= 2;
|
assert(a[20] == 1);
|
assert(a[20] == 1);
|
a[20] |= 2;
|
a[20] |= 2;
|
assert(a[20] == 3);
|
assert(a[20] == 3);
|
a[20] &= 2;
|
a[20] &= 2;
|
assert(a[20] == 2);
|
assert(a[20] == 2);
|
a[20] <<= 1;
|
a[20] <<= 1;
|
assert(a[20] == 4);
|
assert(a[20] == 4);
|
a[20] >>= 1;
|
a[20] >>= 1;
|
assert(a[20] == 2);
|
assert(a[20] == 2);
|
assert(a[0] == 1);
|
assert(a[0] == 1);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("increment",
|
test("increment",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
a++;
|
a++;
|
assert(a == 2);
|
assert(a == 2);
|
a--;
|
a--;
|
assert(a == 1);
|
assert(a == 1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("assert 0",
|
test("assert 0",
|
"""int main(){
|
"""int main(){
|
assert(1);
|
assert(1);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test_fails("assert 1",
|
test_fails("assert 1",
|
"""int main(){
|
"""int main(){
|
assert(0);
|
assert(0);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("assign",
|
test("assign",
|
"""int main(){
|
"""int main(){
|
int a;
|
int a;
|
int b;
|
int b;
|
int c;
|
int c;
|
a = 10;
|
a = 10;
|
b = 20;
|
b = 20;
|
c = a + b;
|
c = a + b;
|
assert(a == 10);
|
assert(a == 10);
|
assert(b == 20);
|
assert(b == 20);
|
assert(c == 30);
|
assert(c == 30);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("while",
|
test("while",
|
"""int main(){
|
"""int main(){
|
int a = 10;
|
int a = 10;
|
int b = 0;
|
int b = 0;
|
while(a){
|
while(a){
|
a = a - 1;
|
a = a - 1;
|
b = b + 1;
|
b = b + 1;
|
}
|
}
|
assert(b == 10);
|
assert(b == 10);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("while 1",
|
test("while 1",
|
"""int main(){
|
"""int main(){
|
int a = 0;
|
int a = 0;
|
while(1){
|
while(1){
|
a = a + 1;
|
a = a + 1;
|
if(a == 10){
|
if(a == 10){
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
}
|
}
|
""")
|
""")
|
test("while 2",
|
test("while 2",
|
"""int main(){
|
"""int main(){
|
while(0){
|
while(0){
|
assert(0);
|
assert(0);
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("if",
|
test("if",
|
"""int main(){
|
"""int main(){
|
int a = 0;
|
int a = 0;
|
int b = 0;
|
int b = 0;
|
if(a){
|
if(a){
|
b = 10;
|
b = 10;
|
assert(0);
|
assert(0);
|
} else {
|
} else {
|
b = 20;
|
b = 20;
|
}
|
}
|
assert(b == 20);
|
assert(b == 20);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("if 1",
|
test("if 1",
|
"""int main(){
|
"""int main(){
|
int a = 1;
|
int a = 1;
|
int b = 0;
|
int b = 0;
|
if(a){
|
if(a){
|
b = 10;
|
b = 10;
|
} else {
|
} else {
|
b = 20;
|
b = 20;
|
assert(0);
|
assert(0);
|
}
|
}
|
assert(b == 10);
|
assert(b == 10);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("if 2",
|
test("if 2",
|
"""int main(){
|
"""int main(){
|
int b = 0;
|
int b = 0;
|
if(0){
|
if(0){
|
b = 10;
|
b = 10;
|
assert(0);
|
assert(0);
|
} else {
|
} else {
|
b = 20;
|
b = 20;
|
}
|
}
|
assert(b == 20);
|
assert(b == 20);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("if 3",
|
test("if 3",
|
"""int main(){
|
"""int main(){
|
int b = 0;
|
int b = 0;
|
if(1){
|
if(1){
|
b = 10;
|
b = 10;
|
} else {
|
} else {
|
b = 20;
|
b = 20;
|
assert(0);
|
assert(0);
|
}
|
}
|
assert(b == 10);
|
assert(b == 10);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("if 4",
|
test("if 4",
|
"""int main(){
|
"""int main(){
|
int b = 0;
|
int b = 0;
|
if(0){
|
if(0){
|
b = 10;
|
b = 10;
|
assert(0);
|
assert(0);
|
}
|
}
|
assert(b == 0);
|
assert(b == 0);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("for 0",
|
test("for 0",
|
"""int main(){
|
"""int main(){
|
int a = 0;
|
int a = 0;
|
int b;
|
int b;
|
int c = 1;
|
int c = 1;
|
for(a=0; a<10; a++){
|
for(a=0; a<10; a++){
|
b = b + 1;
|
b = b + 1;
|
c = c + 1;
|
c = c + 1;
|
}
|
}
|
assert(b == 10);
|
assert(b == 10);
|
assert(c == 11);
|
assert(c == 11);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("for 1",
|
test("for 1",
|
"""int main(){
|
"""int main(){
|
int a = 0;
|
int a = 0;
|
int b;
|
int b;
|
int c = 1;
|
int c = 1;
|
for(; a<10; a++){
|
for(; a<10; a++){
|
b = b + 1;
|
b = b + 1;
|
c = c + 1;
|
c = c + 1;
|
}
|
}
|
assert(b == 10);
|
assert(b == 10);
|
assert(c == 11);
|
assert(c == 11);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("for 2",
|
test("for 2",
|
"""int main(){
|
"""int main(){
|
int a = 0;
|
int a = 0;
|
int b;
|
int b;
|
int c = 1;
|
int c = 1;
|
for(;a<10;){
|
for(;a<10;){
|
b = b + 1;
|
b = b + 1;
|
c = c + 1;
|
c = c + 1;
|
a++;
|
a++;
|
}
|
}
|
assert(b == 10);
|
assert(b == 10);
|
assert(c == 11);
|
assert(c == 11);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("for 3",
|
test("for 3",
|
"""int main(){
|
"""int main(){
|
int a = 0;
|
int a = 0;
|
int b;
|
int b;
|
int c = 1;
|
int c = 1;
|
for(;;){
|
for(;;){
|
if(a>=10) break;
|
if(a>=10) break;
|
b = b + 1;
|
b = b + 1;
|
c = c + 1;
|
c = c + 1;
|
a++;
|
a++;
|
}
|
}
|
assert(b == 10);
|
assert(b == 10);
|
assert(c == 11);
|
assert(c == 11);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("number 0",
|
test("number 0",
|
"""int main(){
|
"""int main(){
|
return 1;
|
return 1;
|
}
|
}
|
""")
|
""")
|
test("report 0",
|
test("report 0",
|
"""int main(){
|
"""int main(){
|
int a = 0;
|
int a = 0;
|
int b = 1;
|
int b = 1;
|
int c = 2;
|
int c = 2;
|
report(a);
|
report(a);
|
report(b);
|
report(b);
|
report(c);
|
report(c);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("declare 0",
|
test("declare 0",
|
"""int main(){
|
"""int main(){
|
int a = 10;
|
int a = 10;
|
int b = 20, c = 30;
|
int b = 20, c = 30;
|
int d[100], e[200];
|
int d[100], e[200];
|
assert(a==10);
|
assert(a==10);
|
assert(b==20);
|
assert(b==20);
|
assert(c==30);
|
assert(c==30);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("wait_clocks 0",
|
test("wait_clocks 0",
|
"""int main(){
|
"""int main(){
|
int a = 10;
|
int a = 10;
|
wait_clocks(a);
|
wait_clocks(a);
|
wait_clocks(10);
|
wait_clocks(10);
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test("function",
|
test("function",
|
"""
|
"""
|
|
|
int func(int a){
|
int func(int a){
|
return a + 10;
|
return a + 10;
|
}
|
}
|
|
|
int main(){
|
int main(){
|
int a = func(10);
|
int a = func(10);
|
assert(a == 20);
|
assert(a == 20);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("function 1",
|
test("function 1",
|
"""
|
"""
|
|
|
int func(int a){
|
int func(int a){
|
assert(a == 20);
|
assert(a == 20);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int main(){
|
int main(){
|
func(20);
|
func(20);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("function 2",
|
test("function 2",
|
"""
|
"""
|
|
|
int func(int a, int b, int c){
|
int func(int a, int b, int c){
|
return a;
|
return a;
|
}
|
}
|
|
|
int main(){
|
int main(){
|
assert(func(1, 2, 3) == 1);
|
assert(func(1, 2, 3) == 1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("function 3",
|
test("function 3",
|
"""
|
"""
|
|
|
int func(int a, int b, int c){
|
int func(int a, int b, int c){
|
return b;
|
return b;
|
}
|
}
|
|
|
int main(){
|
int main(){
|
assert(func(1, 2, 3) == 2);
|
assert(func(1, 2, 3) == 2);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("function 4",
|
test("function 4",
|
"""
|
"""
|
|
|
int func(int a, int b, int c){
|
int func(int a, int b, int c){
|
return c;
|
return c;
|
}
|
}
|
|
|
int main(){
|
int main(){
|
assert(func(1, 2, 3) == 3);
|
assert(func(1, 2, 3) == 3);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("function 5",
|
test("function 5",
|
"""
|
"""
|
|
|
int another(int a){
|
int another(int a){
|
return a + 1;
|
return a + 1;
|
}
|
}
|
|
|
int func(int a){
|
int func(int a){
|
return another(a) + 1;
|
return another(a) + 1;
|
}
|
}
|
|
|
int main(){
|
int main(){
|
assert(func(0) == 2);
|
assert(func(0) == 2);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test_fails("function 6",
|
test_fails("function 6",
|
"""
|
"""
|
|
|
int func(int a, int b){
|
int func(int a, int b){
|
return b;
|
return b;
|
}
|
}
|
|
|
int main(){
|
int main(){
|
assert(func(1, 2, 3) == 3);
|
assert(func(1, 2, 3) == 3);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 1",
|
test("expression 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
int b = 2;
|
int b = 2;
|
int c = 3;
|
int c = 3;
|
assert(a + b + c == 6);
|
assert(a + b + c == 6);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 2",
|
test("expression 2",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
int b = 2;
|
int b = 2;
|
int c = 3;
|
int c = 3;
|
assert(a - b - c == -4);
|
assert(a - b - c == -4);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 3",
|
test("expression 3",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
int b = 2;
|
int b = 2;
|
int c = 3;
|
int c = 3;
|
assert(a - (b - c) == 2);
|
assert(a - (b - c) == 2);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 4",
|
test("expression 4",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
int b = 2;
|
int b = 2;
|
int c = 3;
|
int c = 3;
|
assert(a * b * c == 6);
|
assert(a * b * c == 6);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 5",
|
test("expression 5",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
int b = 2;
|
int b = 2;
|
int c = 3;
|
int c = 3;
|
assert(a/b/c == 0);
|
assert(a/b/c == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 6",
|
test("expression 6",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
int b = 2;
|
int b = 2;
|
int c = 3;
|
int c = 3;
|
assert(a%b%c == 1);
|
assert(a%b%c == 1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 7",
|
test("expression 7",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
int b = 2;
|
int b = 2;
|
int c = 3;
|
int c = 3;
|
assert(-a - (b - c) == 0);
|
assert(-a - (b - c) == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 8",
|
test("expression 8",
|
"""
|
"""
|
int fail(){
|
int fail(){
|
assert(0);
|
assert(0);
|
return 0;
|
return 0;
|
}
|
}
|
int main(){
|
int main(){
|
int a = 0 && fail();
|
int a = 0 && fail();
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 9",
|
test("expression 9",
|
"""
|
"""
|
int fail(){
|
int fail(){
|
assert(0);
|
assert(0);
|
return 0;
|
return 0;
|
}
|
}
|
int main(){
|
int main(){
|
int a = 1 || fail();
|
int a = 1 || fail();
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 10",
|
test("expression 10",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
assert(a << 2 == 4);
|
assert(a << 2 == 4);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 11",
|
test("expression 11",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
int b = 2;
|
int b = 2;
|
assert(a << b == 4);
|
assert(a << b == 4);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 12",
|
test("expression 12",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 4;
|
int a = 4;
|
assert(a >> 2 == 1);
|
assert(a >> 2 == 1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 13",
|
test("expression 13",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 4;
|
int a = 4;
|
int b = 2;
|
int b = 2;
|
assert(a >> b == 1);
|
assert(a >> b == 1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 14",
|
test("expression 14",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = -1;
|
int a = -1;
|
assert(~a == 0);
|
assert(~a == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 15",
|
test("expression 15",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 1;
|
int a = 1;
|
assert(!a == 0);
|
assert(!a == 0);
|
int a = 0;
|
int a = 0;
|
assert(!a == 1);
|
assert(!a == 1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 16",
|
test("expression 16",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 0xA;
|
int a = 0xA;
|
int b = 0x5;
|
int b = 0x5;
|
assert((a | b) == 0xF);
|
assert((a | b) == 0xF);
|
assert((a ^ b) == 0xf);
|
assert((a ^ b) == 0xf);
|
assert((a & b) == 0);
|
assert((a & b) == 0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 17",
|
test("expression 17",
|
"""
|
"""
|
int fail(){
|
int fail(){
|
assert(0);
|
assert(0);
|
return 0;
|
return 0;
|
}
|
}
|
int main(){
|
int main(){
|
int b = 0;
|
int b = 0;
|
int a = b && fail();
|
int a = b && fail();
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 18",
|
test("expression 18",
|
"""
|
"""
|
int fail(){
|
int fail(){
|
assert(0);
|
assert(0);
|
return 0;
|
return 0;
|
}
|
}
|
int main(){
|
int main(){
|
assert(~1);
|
assert(~1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 19",
|
test("expression 19",
|
"""
|
"""
|
int main(){
|
int main(){
|
assert(-1 < 1);
|
assert(-1 < 1);
|
assert(-1 < 0);
|
assert(-1 < 0);
|
assert(0 <= 0);
|
assert(0 <= 0);
|
assert(0 >= 0);
|
assert(0 >= 0);
|
assert(1 >= 0);
|
assert(1 >= 0);
|
assert(1 >= -1);
|
assert(1 >= -1);
|
assert(1 > -1);
|
assert(1 > -1);
|
assert(1 > 0);
|
assert(1 > 0);
|
assert(12 != 13);
|
assert(12 != 13);
|
assert(100 == 100);
|
assert(100 == 100);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("expression 20",
|
test("expression 20",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = -1;
|
int a = -1;
|
assert(a >> 2 == -1);
|
assert(a >> 2 == -1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("comment 0",
|
test("comment 0",
|
"""
|
"""
|
int main(){
|
int main(){
|
//assert(0);
|
//assert(0);
|
//assert(0);
|
//assert(0);
|
//assert(0);
|
//assert(0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("comment 1",
|
test("comment 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
/*assert(0);
|
/*assert(0);
|
assert(0);
|
assert(0);
|
assert(0);*/
|
assert(0);*/
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
test("array 0",
|
test("array 0",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a [1024];
|
int a [1024];
|
int b [1024];
|
int b [1024];
|
a[0] = 1;
|
a[0] = 1;
|
a[1] = 2;
|
a[1] = 2;
|
a[3] = 3;
|
a[3] = 3;
|
assert(a[0] == 1);
|
assert(a[0] == 1);
|
assert(a[1] == 2);
|
assert(a[1] == 2);
|
assert(a[3] == 3);
|
assert(a[3] == 3);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("array 1",
|
test("array 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a [1024];
|
int a [1024];
|
int b [1024];
|
int b [1024];
|
a[0] = 10;
|
a[0] = 10;
|
b[0] = 20;
|
b[0] = 20;
|
a[1] = 30;
|
a[1] = 30;
|
b[1] = 40;
|
b[1] = 40;
|
a[3] = 50;
|
a[3] = 50;
|
b[3] = 60;
|
b[3] = 60;
|
assert(a[0] == 10);
|
assert(a[0] == 10);
|
assert(b[0] == 20);
|
assert(b[0] == 20);
|
assert(a[1] == 30);
|
assert(a[1] == 30);
|
assert(b[1] == 40);
|
assert(b[1] == 40);
|
assert(a[3] == 50);
|
assert(a[3] == 50);
|
assert(b[3] == 60);
|
assert(b[3] == 60);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test_fails("error 0",
|
test_fails("error 0",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a;
|
int a;
|
a = c;
|
a = c;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test_fails("error 1",
|
test_fails("error 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a;
|
int a;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test_fails("error 2",
|
test_fails("error 2",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a blah;
|
int a blah;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test_fails("error 3",
|
test_fails("error 3",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a;
|
int a;
|
b = a;
|
b = a;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test_fails("error 4",
|
test_fails("error 4",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a;
|
int a;
|
a = c();
|
a = c();
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test_fails("error 5",
|
test_fails("error 5",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a;
|
int a;
|
a==;
|
a==;
|
}
|
}
|
|
|
""")
|
""")
|
test_fails("error 6",
|
test_fails("error 6",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a;
|
int a;
|
a=00x;
|
a=00x;
|
}
|
}
|
|
|
""")
|
""")
|
test_fails("error 7",
|
test_fails("error 7",
|
"""
|
"""
|
int main(){
|
int main(){
|
switch(1){
|
switch(1){
|
case 0:
|
case 0:
|
default:
|
default:
|
default:
|
default:
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test_fails("error 8",
|
test_fails("error 8",
|
"""
|
"""
|
int main(){
|
int main(){
|
default:
|
default:
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test_fails("error 9",
|
test_fails("error 9",
|
"""
|
"""
|
int main(){
|
int main(){
|
case 1:
|
case 1:
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test_fails("error 10",
|
test_fails("error 10",
|
"""
|
"""
|
int main(){
|
int main(){
|
int a = 12;
|
int a = 12;
|
switch(a){
|
switch(a){
|
case a + 1:
|
case a + 1:
|
a++;
|
a++;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
test_fails("error 11",
|
test_fails("error 11",
|
"""
|
"""
|
int myfunction(){
|
int myfunction(){
|
return 0;
|
return 0;
|
}
|
}
|
int main(){
|
int main(){
|
int a = 12;
|
int a = 12;
|
myfunction()=10;
|
myfunction()=10;
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
|
|
|
test_fails("error 12",
|
|
"""
|
|
|
|
typedef struct {long int a; int b;} struct_1;
|
|
typedef struct {long int a; struct_1 b;} mystruct;
|
|
|
|
void test(mystruct my){
|
|
assert(mystruct.a == 1);
|
|
assert(mystruct.b.a == 2);
|
|
assert(mystruct.b.b == 3);
|
|
}
|
|
|
|
void main(){
|
|
mystruct blah;
|
|
blah.a = 1;
|
|
blah.b.a = 2;
|
|
blah.b.b = 3;
|
|
test(blah);
|
|
}
|
|
"""
|
|
)
|
|
|
test("input 1",
|
test("input 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
int b;
|
int b;
|
b = input_a();
|
b = input_a();
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("output 1",
|
test("output 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
output_a(12);
|
output_a(12);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("input output 1",
|
test("input output 1",
|
"""
|
"""
|
int main(){
|
int main(){
|
if (input_select()){
|
if (input_select()){
|
output_z(input_a());
|
output_z(input_a());
|
} else {
|
} else {
|
output_z(input_b());
|
output_z(input_b());
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("input output 2",
|
test("input output 2",
|
"""
|
"""
|
int arbiter(){
|
int arbiter(){
|
while(1){
|
while(1){
|
if(ready_a()) output_z(input_a());
|
if(ready_a()) output_z(input_a());
|
if(ready_b()) output_z(input_b());
|
if(ready_b()) output_z(input_b());
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
""")
|
""")
|
|
|
test("main not main",
|
test("main not main",
|
"""
|
"""
|
int main(){
|
int main(){
|
assert(0);
|
assert(0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
//last function is always main
|
//last function is always main
|
int real_main(){
|
int real_main(){
|
return 0;
|
return 0;
|
}
|
}
|
""")
|
""")
|
|
|
os.system("python-coverage run -p c2verilog.py")
|
os.system("python-coverage run -p ../c2verilog")
|
os.system("python-coverage combine")
|
os.system("python-coverage combine")
|
os.system("python-coverage report")
|
os.system("python-coverage report")
|
os.system("python-coverage annotate c2verilog.py")
|
os.system("python-coverage annotate ../c2verilog")
|
os.system("python-coverage annotate compiler/parser.py")
|
os.system("python-coverage annotate ../chips/compiler/parser.py")
|
|
|
