def run():
parser1 = Parser()
parser1.parse_file(PositiveCombinationTest.testfile1)
backend1 = Z3Backend(name=PositiveCombinationTest.testfile1,
voi="variable")
backend1.log.setLevel(logging.ERROR)
backend1.exec_statements(parser1.statements)
parser2 = Parser()
parser2.parse_file(PositiveCombinationTest.testfile2)
backend2 = Z3Backend(name=PositiveCombinationTest.testfile2,
voi="variable")
backend2.log.setLevel(logging.ERROR)
backend2.exec_statements(parser2.statements)
backend = backend1 & backend2
backend.log.setLevel(logging.ERROR)
solver = backend.solver
model = backend.model
assert model, "Model unsat. Test failed"
testcase = backend.generate_testcase("variable")
testcase = unpack(testcase, 'all')
assert(testcase > 15)
assert(testcase & 0xffff == 0)
assert((testcase & (testcase - 1) != 0))
return True
def run():
parser = Parser()
parser.parse_file(AlgebraTest.testfile)
backend = Z3Backend()
backend.log.setLevel(logging.ERROR)
backend.exec_statements(parser.statements)
solver = backend.generate_solver()
variables = backend.variables
input = variables['VARIABLE']
v1 = variables['VARA']
v2 = variables['VARB']
v3 = variables['VARC']
v4 = variables['VARD']
v5 = variables['VARE']
v6 = variables['VARF']
solver.add(input == 10)
assert (solver.check() == z3.sat)
model = solver.model()
assert (model.eval(v1).as_long() == 15)
assert (model.eval(v2).as_long() == 5)
assert (model.eval(v3).as_long() == 50)
assert (model.eval(v4).as_long() == 2)
assert (model.eval(v5).as_long() == 2)
assert (model.eval(v6).as_long() == 0)
def run():
parser = Parser()
parser.parse_file(AlignmentTest.testfile)
backend = Z3Backend()
backend.log.setLevel(logging.ERROR)
backend.exec_statements(parser.statements)
solver = backend.generate_solver()
assert (solver.check() == z3.sat)
def run():
parser = Parser()
parser.parse_file(StringCompareTest.testfile)
backend = Z3Backend()
backend.log.setLevel(logging.ERROR)
backend.exec_statements(parser.statements)
solver = backend.generate_solver()
assert (solver.check() == z3.sat)
model = solver.model()
outvar = backend.variables['out']
assert (model.eval(outvar).as_long() == 0x5241424f4f4600)
def run():
parser = Parser()
parser.parse_file(ConditionalLoopTest.testfile)
backend = Z3Backend()
backend.log.setLevel(logging.ERROR)
backend.exec_statements(parser.statements)
solver = backend.solver
model = backend.model
assert model, "Model unsat. Test failed"
testcase = backend.generate_testcase()
expected = b'\x01' * 4
assert (testcase[4:8] == expected)
def run():
parser = Parser(pwd=os.path.dirname(os.path.realpath(__file__)))
parser.parse_file(FromFileTest.testfile)
backend = Z3Backend()
backend.log.setLevel(logging.ERROR)
backend.exec_statements(parser.statements)
solver = backend.solver
model = backend.model
assert model, "Model unsat. Test failed"
testcase = backend.generate_testcase(varname="file")
assert (testcase[5:5 + 10] == b"1337133713")
return True
def run():
parser = Parser()
parser.parse_file(OverflowTest.testfile)
backend = Z3Backend()
backend.log.setLevel(logging.ERROR)
backend.exec_statements(parser.statements)
solver = backend.generate_solver()
variables = backend.variables
### Check sat
assert(backend.model)
model = backend.model
var4 = model.eval(variables['VAR4']).as_long()
var5 = model.eval(variables['VAR5']).as_long()
assert(var4 + var5 >= 0x100000000)
def run():
parser = Parser()
parser.parse_file(BitwiseTest.testfile)
backend = Z3Backend()
backend.log.setLevel(logging.ERROR)
backend.exec_statements(parser.statements)
solver = backend.generate_solver()
input = backend.variables['VARIABLE']
v1 = backend.variables['VARA']
v2 = backend.variables['VARB']
v3 = backend.variables['VARC']
solver.add(input == 0xdeadbeef)
assert(solver.check() == z3.sat)
model = solver.model()
assert(model.eval(v1).as_long() == 0x11001)
assert(model.eval(v2).as_long() == 0xdfadbeef)
assert(model.eval(v3).as_long() == 0x21524110)
def run():
parser = Parser(pwd=os.path.dirname(os.path.realpath(__file__)))
parser.parse_file(OptimizationTest.testfile)
backend = Z3Backend()
backend.log.setLevel(logging.ERROR)
backend.exec_statements(parser.statements)
solver = backend.solver
model = backend.model
assert model, "Model unsat. Test failed"
var1 = backend.generate_testcase(varname="var1")
var2 = backend.generate_testcase(varname="var2")
var1 = unpack(var1, 'all', endianness="little")
var2 = unpack(var2, 'all', endianness="little")
assert var1 == var2 == 10
return True
def run():
parser = Parser()
parser.parse_file(VLoopTest.testfile)
backend = Z3Backend()
backend.log.setLevel(logging.ERROR)
backend.exec_statements(parser.statements)
solver = backend.solver
model = backend.model
assert model, "Model unsat. Test failed"
testcase = backend.generate_testcase()
expected = b''.join([x.to_bytes(1, 'little') for x in range(0x10)])
assert testcase[:
0x10] == expected, "First part of the testcase not as expected"
assert all(
x == 0 for x in
testcase[0x10:]), "Second part of the testcase not as expected"
return True