def test_complex_bin_op(self):
test_case = dedent("""\
import math
class Cell: pass
def Top(bn: int, en_pp: bool, re: bool, pp_num: int):
# IO: have 55 io in each local block
max_rlc = 55
nlc = (bn -1)/max_rlc + 1
pp_num = pp_num + re
if(en_pp):
nlc = 3
pp_num = pp_num + re
bn = bn + nlc * re
cell0 = Cell()
cell1 = Cell()
cell2 = Cell()
cell3 = Cell()
cell4 = Cell()
cell5 = Cell()
cell6 = Cell()
pat1 = [cell0, cell1, cell2] if re else [cell2, cell3]
pat2 = [cell1, cell2] if pp_num else [cell2, cell3]
pat3 = [cell4, cell5] if re else [cell4, cell6]
pattern1 = []
if pp_num and bn == 1:
pattern1 = pat1 + pat2 * pp_num + pat3
return pattern1
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 4)
def test_none_result(self):
test_case = dedent("""
def foo(x: int, y: int):
if x != 2 or y != 100:
return None
else:
return True
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
def test_divmod(self):
test_case = dedent("""\
def Top(pp_en: bool, cm: int, mc: int):
if divmod(cm, mc)[0] == 2:
return 3
else:
return 4
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_num_of_assert(ret, 2)
def test_identity_comparison(self):
test_case = dedent("""\
def Top(pp_en: bool, cm: int, mc: int):
if cm == 2 and cm is mc and type(cm) is int:
return 3
else:
return 4
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_num_of_assert(ret, 2)
def test_str_conversion(self):
test_case = dedent("""\
def Top(x: int, y: str):
if str(x) == "23" and y == "a number":
return "number is: " + str(x) + str(y)
else:
return "number is: " + str(x)
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 2)
def test_builtin_result(self):
test_case = dedent("""\
def Top(cm: int, en: bool):
cell = None
if cm > 2 and en:
cell = "cell_" + str(cm) * int(cm)
return cell
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 2)
def test_container_binop(self):
test_case = dedent("""\
def Top(x: int, y: str):
if 1 + x > 2:
return [1, 2] * x
else:
return "something" * x
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 2)
def test_bool_op(self):
test_case = dedent("""\
def Top(en: bool, bool1: bool):
pattern = 3
if not en and bool1:
pattern = pattern + (not en and bool1)
return pattern
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 2)
def test_default_arg(self):
test_case = dedent("""
def foo(x: int, y: int, default: str="") -> str:
if x + y > 2:
return default + default
else:
return x - y
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 2)
def test_string_mult(self):
test_case = dedent("""
def foo(x: int, y: int, default: str="") -> str:
if x > 1 and (default * x) == "somethingsomething":
return default * (x + y)
else:
return x - y
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 2)
def test_invalid_primitive_type(self):
test_case = dedent("""
import icontract
@icontract.require(lambda x: x > 100)
def foo(x: str):
if x == "something":
return 1
else:
return 2
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_num_of_assert(ret, 2)
def test_explosive_result(self):
test_case = dedent("""\
import math
def Top(number: int, pp_en: bool, re: bool, pp_key_num: int, x: int):
# IO: have 55 io in each local block
max_rlc = 55
nlc = (number -1)//max_rlc + 1
pp_key_num = pp_key_num + re
if(pp_en):
nlc = 3
pp_key_num = pp_key_num + re
number = number + nlc * re
number_2lc = 0
if nlc == 2:
nio_1lc = int(math.ceil(float(number)/4))
number_1lc = nio_1lc * 2
number_2lc = number - number_1lc
elif nlc == 3:
if pp_en:
number_1lc = pp_key_num
else:
nio_1lc = int(math.ceil(float(number)/6))
number_1lc = nio_1lc * 2
number_remain = number - number_1lc
nio_2lc = int(math.ceil(float(number_remain)/4))
number_2lc = nio_2lc * 2
number_2lc = number_2lc - re
if number_2lc <= 0:
x = "2"
elif number_2lc <= 4:
x = "3"
elif number_2lc <= 8:
x = "4"
elif number_2lc <= 16:
x = "5"
elif number_2lc <= 32:
x = "6"
else:
x = "7"
return x
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 10)
def test_triangle(self):
test_case = dedent("""
def triangle(x: int, y: int, z: int) -> str:
if x == y == z:
return "Equilateral triangle"
elif x == y or y == z or x == z:
return "Isosceles triangle"
else:
return "Scalene triangle"
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 3)
def test_invalid_preconditions(self):
test_case = dedent("""
import icontract
@icontract.require(lambda x: x > 100)
def foo(x: int):
if x < 100:
return 1
else:
return 2
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 1)
def test_require_simple(self):
test_case = dedent("""
import icontract
@icontract.require(lambda x, y: x + y > 100)
def foo(x: int, y: int):
if x > y:
return x + 5
else:
return x - 10
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 2)
def test_bool_and(self):
test_case = dedent("""\
def Top(pp_en: bool, cm: int, ss: int, s: str, en: bool):
if not pp_en and cm == 2 and en:
r = (pp_en and en) or en
elif (pp_en or s) > 0:
r = 999
else:
r = 2
return r
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_num_of_assert(ret, 3)
def test_bool_node_error(self):
test_case = dedent("""\
def Top(pp_en: bool, cm: int, ss: int, s: str):
if pp_en and cm == 2:
r = bool or pp_en
elif (pp_en or s) > 0:
r = 999
else:
r = 2
return r
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_num_of_assert(ret, 3)
def test_operand_model_changed(self):
test_case = dedent("""\
def Top(cm: int):
pattern = 3
if cm >= 2:
pattern = pattern * cm
if cm <= 2:
pattern = pattern * cm
return pattern
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 3)
def test_ensure_have_arg(self):
test_case = dedent("""
import icontract
@icontract.ensure(lambda x, result: (result + x) > 100)
def foo(x: int, y: int):
if x > y:
return x + 5
else:
return x - 10
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 2)
def test_func_call(self):
test_case = dedent("""
def fee(x, y):
return x + y * y
def foo(x: int, y: int) -> str:
if fee(y, x) > 2:
return x + y
else:
return x - y
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 2)
def test_z3_bool_op(self):
test_case = dedent("""\
def Top(pp_en: bool, cm: int, ss: int, st: str):
if ss == 0 and cm == 2:
r = (cm and ss) + 1 # 1
elif cm == 0 and (cm or ss) == 13:
r = ss # 13
else:
r = st or ss
return r
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 3)
def test_compare_multiple_comparators(self):
test_case = dedent("""\
def Top(pp_en: bool, cm: int, ss: int):
if pp_en and cm == 2:
r = 2 + (cm or (pp_en and (cm <= 2) and (cm == 2)))
elif (cm or ss) + 2 > 88:
r = 999
else:
r = 2
return r
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 3)
def test_bool_short_circuiting(self):
test_case = dedent("""\
def Top(x: int, y: str):
a = 11 if x > 2 else 13
b = 16 if y == "something" else 15
if a or b:
z = 1
else:
z = 2
return z
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 2)
def test_ifexp_bool_context(self):
test_case = dedent("""\
def Top(x: int, y: str):
a = 11 if x else 13 if y else 111
b = 16 if y else 15 if x > 12 else 124
if (a and b and a or b):
z = 1
else:
z = 2
return z
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 5)
def test_return_result_default(self):
test_case = dedent("""
def fee(x, y):
return x + y * y
def foo(x: int, y: int, z: str="default"):
if fee(y, x) > 2:
return z
else:
return x - y
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 2)
def test_unrelated_arg(self):
test_case = dedent("""\
def Top(cm: int):
if cm == 3:
e = 1
else:
e = 2
ret = 13
if cm >= 50:
ret = 3
return ret
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 2)
def test_ensure_require(self):
test_case = dedent("""
import icontract
@icontract.require(lambda y: y > 2555.5)
@icontract.require(lambda x, y: x > 100 and y > 14.5)
@icontract.ensure(lambda x, result: (result + x) > 1000)
def foo(x: int, y: float):
if x > y:
return x + 5
else:
return x - 10
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 2)
def test_string(self):
test_case = dedent("""
def foo(x: int, y: int, zz: str, z: str="value_default"):
if x + y > 2:
return x + y + 12
elif x < y:
return x + y
elif (z + "me") == "some":
return z + "thing" + zz
else:
return x - y
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 4)
def test_list_mult(self):
test_case = dedent("""\
class Cell: pass
def Top(bn: int, v: int):
cell0 = Cell()
cell1 = Cell()
cell2 = Cell()
cell3 = Cell()
pat1 = [cell0, cell1, cell2] if bn > 2 else [cell2, cell3]
z = 1 if v > 3 else 2
return [0, 1, 2] + pat1 * z
""")
ret = run(test_case, self._TEST_MODULE_NAME)
self.assert_test_ran(test_case, ret)
self.assert_num_of_assert(ret, 4)
def test_not_supported_type(self):
test_case = dedent("""
import icontract
class T:
x: int = 0
@icontract.require(lambda x: x is not None)
def foo(x: T):
if x.x == 2:
return 1
else:
return 2
""")
ret = run(test_case, self._TEST_MODULE_NAME)
assert ret
