def test_global_variable_exist():
tree = tr("variable", "a")
stack = Stack()
stack.add_global("a", Real)
expression: Expression = parser.handle(tree, stack)
assert expression.type == Real
assert expression.expression == ["a"]
def test_negation_correct_type(self, type):
tree = tr("negation", tr("variable", "a"))
stack = Stack()
stack.add_global("a", type)
expression = parser.handle(tree, stack)
assert expression.expression == ["-(", "a", ")"]
assert expression.type == type
def test_comparision_incorrect(self, arg1, arg2):
tree = tr("op_3_0", tr("variable", "a"), tr("variable", "b"))
stack = Stack()
stack.add_global("a", arg1)
stack.add_global("b", arg2)
with pytest.raises(CompileTimeError):
parser.handle(tree, stack)
def test_comparision_correct(self, arg1, arg2):
tree = tr("op_3_0", tr("variable", "a"), tr("variable", "b"))
stack = Stack()
stack.add_global("a", arg1)
stack.add_global("b", arg2)
expr: Expression = parser.handle(tree, stack)
assert expr.type == Bool
def test_invalid_arguments_count_many(self):
with pytest.raises(FunctionArgumentsError):
stack = Stack()
stack.add_variable("func", Function(([Integer, Integer], Integer)))
tree = tr("func_call", "func", tr("int_literal", "1"), tr("int_literal", "1"),
tr("int_literal", "1"))
parser.handle(tree, stack)
def test_variable_exist():
tree = tr("variable", "a")
stack = Stack()
stack.add_variable("a", Integer)
expression: Expression = parser.handle(tree, stack)
assert expression.type == Integer
assert expression.expression == ["var_0"]
def test_exception():
code = """
func f()
throw()
end
f()
"""
stack = Stack()
stack.add_global("throw", Function(([], Void)))
expressions = parser.parse(code, stack)
def throw_function():
raise ValueError("~~error~~")
writer = MockTracebackWriter()
writer.print_traceback = MagicMock()
context = ExecutionContext({"throw": throw_function})
context.compile(expressions)
context.execute(writer)
error: RuntimeError = writer.print_traceback.call_args_list[0][0][0]
assert str(error) == "~~error~~"
assert tuple(error.stack_entries[0]) == ("f", 2)
assert tuple(error.stack_entries[1]) == (None, 3)
assert context.code_map[2] == 2
assert context.code_map[3] == 5
def test_return(self):
tree = tr("return_statement", tr("int_literal", "1"))
stack = Stack()
stack.context_return_type = Real
expression = parser.handle(tree, stack)
assert expression.type == Void
assert expression.expression == ["return ", "1"]
def test_no_args(self):
stack = Stack()
stack.add_global("func", Function(([], Integer)))
tree = tr("func_call", "func")
expression = parser.handle(tree, stack)
assert expression.type == Integer
assert expression.expression == ["func", "()"]
def test_list_type_error(self):
stack = Stack()
stack.add_global("a", List(Bool))
tree = tr("var_assignment",
tr("collection_item", tr("variable", "a"), tr("int_literal", "2")),
tr("int_literal", "42"))
with pytest.raises(ValueTypeError):
parser.handle(tree, stack)
def test_list(self):
stack = Stack()
stack.add_global("a", List(Real))
tree = tr("var_assignment",
tr("collection_item", tr("variable", "a"), tr("int_literal", "2")),
tr("int_literal", "42"))
expression = parser.handle(tree, stack)
assert expression.expression == ["(", "a", ")[", "2", "]", " = ", "42"]
def test_list_reference():
stack = Stack()
stack.add_global("a", List(Bool))
tree = tr("collection_item",
tr("variable", "a"),
tr("int_literal", "12"))
expression = parser.handle(tree, stack)
assert expression.expression == ["(", "a", ")[", "12", "]"]
assert expression.type == Bool
def test_no_arguments_no_return(self):
tree = tr("func_decl", "func_name", tr("clause"))
stack = Stack()
expression = parser.handle(tree, stack)
assert isinstance(expression, FunctionDeclarationExpression)
assert expression.name == "var_0"
assert expression.symbol_name == "func_name"
assert expression.arguments == []
assert expression.return_type == Void
assert stack.get_variable("func_name").type == Function(([], Void))
def test_var_declaration(self):
tree = tr("var_decl", "a", "b", "c", tr("type_int"))
stack = Stack()
expressions = parser.handle(tree, stack)
for i, value in enumerate(expressions):
assert value.type == Void
assert value.expression == ["var_" + str(i), " = ", "0"]
assert stack.get_variable("a").type == Integer
assert stack.get_variable("b").type == Integer
assert stack.get_variable("c").type == Integer
def test_value(self):
tree = tr("var_decl", "a", "b", "c", tr("type_int"), tr("int_literal", "1"))
stack = Stack()
values: typing.List[Expression] = parser.handle(tree, stack)
for i, value in enumerate(values):
assert value.type == Void
assert value.expression == ["var_" + str(i), " = ", "1"]
assert stack.get_variable("a").type == Integer
assert stack.get_variable("b").type == Integer
assert stack.get_variable("c").type == Integer
def test_globals():
stack = Stack()
stack.add_global("a", List(Integer))
stack.add_variable("b", Real)
g = stack.get_variable("a")
assert g.type == List(Integer)
assert g.number == -1
stack.add_variable("a", Bool)
g = stack.get_variable("a")
assert g.type == Bool
assert g.number == 1
def test_no_return(self):
tree = tr("func_decl", "func_name",
tr("argument", "a", tr("type_int")),
tr("clause", tr("variable", "a")))
stack = Stack()
expression = parser.handle(tree, stack)
assert isinstance(expression, FunctionDeclarationExpression)
assert expression.name == "var_0"
assert expression.symbol_name == "func_name"
assert expression.arguments == ["var_0"]
assert expression.return_type == Void
assert expression.clause[0].expression == ["var_0"]
assert expression.clause[0].type == Integer
assert stack.get_variable("func_name").type == Function(([Integer], Void))
def test_for_loop_new_var():
stack = Stack()
stack.add_variable("range", List(Integer))
tree = tr("for_expression",
"var",
tr("variable", "range"),
tr("clause", tr("int_literal", "1"), tr("variable", "var")))
expression = parser.handle(tree, stack)
assert isinstance(expression, ForLoopExpression)
assert expression.iterator == "var_1"
assert expression.range.expression == ["var_0"]
assert expression.actions[0].expression == ["1"]
assert expression.actions[1].expression == ["var_1"]
assert expression.actions[1].type == Integer
def test_library_init_stack():
lib = Library()
@lib.function([Integer], Integer)
def func1():
pass
@lib.function([Real], Real)
def func2():
pass
stack = Stack()
lib.initialize_stack(stack)
assert stack.get_variable("func1").type == Function(([Integer], Integer))
assert stack.get_variable("func2").type == Function(([Real], Real))
def test_if_wrong_type():
tree = tr("if_expression",
tr("int_literal", "1"),
tr("float_literal", "2"),
tr("float_literal", "3"))
with pytest.raises(ValueTypeError):
parser.handle(tree, Stack())
def test_operators(self, op1_type: str, op2_type: str, op_name: str, res_type: Type, res_expr: str):
tree = tr(op_name, tr(op1_type, "1"), tr(op2_type, "2"))
expr: Expression = parser.handle(tree, Stack())
assert expr.type == res_type
assert expr.intermediates == []
assert "".join(expr.expression) == res_expr
def test_indices_right(self):
tree = tr("cube_turn_range", tr("cube_left"), tr("range_open_right", tr("int_literal", "1")))
expr = parser.handle(tree, Stack())
assert isinstance(expr, CubeTurningExpression)
assert len(expr.indices) == 2
assert expr.indices[0].expression == ["1"]
assert expr.indices[1].expression == ["..."]
def test_literal(name: str, value: str, exp_type: Type, exp_value: str):
tree = tr(name, value)
expr = parser.handle(tree, Stack())
assert isinstance(expr, Expression)
assert expr.type == exp_type
assert expr.expression == [exp_value]
assert expr.intermediates == []
def test_for_loop_wrong_range():
with pytest.raises(ValueTypeError):
tree = tr("for_expression",
"var",
tr("int_literal", "1"),
tr("int_literal", "1"))
parser.handle(tree, Stack())
def test_indices_single(self):
tree = tr("cube_turn_range", tr("cube_left"), tr("range_value", tr("int_literal", "1")))
expr = parser.handle(tree, Stack())
assert isinstance(expr, CubeTurningExpression)
assert expr.side == "left"
assert len(expr.indices) == 1
assert expr.indices[0].expression == ["1"]
def test_pascals_triangle():
"""
Computes five lines of Pascal's triangle:
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
Values are returned via `print` function line by line separated by `0`.
"""
code = """
let result: list of list of int
let row_size: int = 1
repeat 5 times
let row: list of int = new_list(row_size, 1)
let i: int = 1
while i < row_size - 1 do
row[i] = result[size(result) - 1][i] + result[size(result) - 1][i - 1]
i = i + 1
end
add_last(result, row)
row_size = row_size + 1
end
for row in result do
for x in row do
print(x)
end
print(0)
end
"""
stack = Stack()
stack.add_global("print", Function(([Integer], Void)))
stdlib.initialize_stack(stack)
expressions = parser.parse(code, stack)
print_fn = MagicMock()
context = ExecutionContext(dict(print=print_fn, **stdlib.exec_globals))
context.compile(expressions)
context.execute(MockTracebackWriter())
return_value = [x[0][0] for x in print_fn.call_args_list]
assert return_value == [
1, 0, 1, 1, 0, 1, 2, 1, 0, 1, 3, 3, 1, 0, 1, 4, 6, 4, 1, 0
]
def test_repeat():
tree = tr("repeat_expression",
tr("int_literal", "2"),
tr("bool_literal_true"))
expression = parser.handle(tree, Stack())
assert isinstance(expression, RepeatLoopExpression)
assert expression.type == Void
assert expression.times.expression == ["2"]
assert expression.actions[0].expression == ["True"]
def test_do_while():
tree = tr("do_expression",
tr("int_literal", "2"),
tr("bool_literal_true"))
expression = parser.handle(tree, Stack())
assert isinstance(expression, DoWhileLoopExpression)
assert expression.type == Void
assert expression.condition.expression == ["True"]
assert expression.actions[0].expression == ["2"]
def test_default(self):
tree = tr("func_decl", "func_name",
tr("argument", "a", tr("type_int")),
tr("argument", "b", tr("type_real")),
tr("type_bool"),
tr("clause", tr("variable", "a"), tr("variable", "b")))
stack = Stack()
expression = parser.handle(tree, stack)
assert isinstance(expression, FunctionDeclarationExpression)
assert expression.name == "var_0"
assert expression.symbol_name == "func_name"
assert expression.arguments == ["var_0", "var_1"]
assert expression.return_type == Bool
assert expression.clause[0].expression == ["var_0"]
assert expression.clause[0].type == Integer
assert expression.clause[1].expression == ["var_1"]
assert expression.clause[1].type == Real
assert stack.get_variable("func_name").type == Function(([Integer, Real], Bool))
def test_execution_integration():
"""
Computing pi by integrating:
\\frac{\\pi}{2} = \\int^1_{-1} \\sqrt{1 - x^2} dx
"""
code = """
let delta_x: real = 0.001
let x: real = -1
let y: real = sqrt(1 - x * x)
let result: real
while x + delta_x < 1 do
let next_x: real = x + delta_x
let next_y: real = sqrt(1 - next_x * next_x)
result = result + (y + next_y) / 2 * delta_x
y = next_y
x = next_x
end
print(result * 2)
"""
stack = Stack()
stack.add_global("print", Function(([Real], Void)))
stack.add_global("sqrt", Function(([Real], Real)))
expressions = parser.parse(code, stack)
context = ExecutionContext(dict(print=MagicMock(), sqrt=math.sqrt))
context.compile(expressions)
context.execute(MockTracebackWriter())
return_value = context.globals["print"].call_args[0][0]
assert abs(return_value - math.pi) < 0.01
