def test_container_not_vector_should_give_error(self):
none_vector_exprs = [Expression(Type.int(), 1, "a"), Expression(Type.decimal(), 1.0, "a"),
Expression(Type.boolean(), True, "a"), Expression(Type.string(), "abc", "a"),
Expression(Type.list_of(Type.decimal()), [1.0, 1.0, 1.0], "a"),
Expression(Type.list_of(Type.list_of(Type.decimal())), [[1.0, 1.0, 1.0]], "a")]
for none_vector_expr in none_vector_exprs:
with self.assertRaises(AssertionError) as context:
VectorElem("a", none_vector_expr, 0)
def test_to_expression_should_return_correct_value(self):
expression = Expression(Type.vector(), [1.0, 2.0, 3.0], "a")
expected = Expression(Type.decimal(), 1.0)
self.assertEqual(expected, VectorElem("a", expression, 0).to_expression())
expression = Expression(Type.vector(), [1.0, 2.0, 3.0], "b[1]")
expected = Expression(Type.decimal(), 3.0)
self.assertEqual(expected, VectorElem("b[1]", expression, 2).to_expression())
def test_to_expression_should_return_correct_value(self):
expressions = [None, Expression(Type.int(), 1, "a"), Expression(Type.decimal(), 1.1, "a"),
Expression(Type.boolean(), False, "a"),
Expression(Type.vector(), [1.1, 2.2, -1.1], "a"),
Expression(Type.list_of(Type.int()), [1, 2, 3, 4], "a"),
Expression(Type.list_of(Type.int()), [], "a"),
Expression(Type.list_of(Type.decimal()), [1.0, 2.0, 3.0, 4.0], "a"),
Expression(Type.list_of(Type.list_of(Type.vector())), [[[1.1, 2.2, -1.1], [1, 2, -1]]], "a")]
for expression in expressions:
self.assertEqual(expression, Identifier("a", expression).to_expression())
def test_to_expression_should_return_correct_value(self):
expression = Expression(Type.list_of(Type.decimal()), [1.0, 2.0, 3.0, 4.0], "a")
expected = Expression(Type.decimal(), 1.0, "a[0]")
self.assertEqual(expected, ListElem("a", expression, 0).to_expression())
expression = Expression(Type.list_of(Type.list_of(Type.vector())), [[[1.1, 2.2, -1.1], [1, 2, -1]]], "a")
expected = Expression(Type.list_of(Type.vector()), [[1.1, 2.2, -1.1], [1, 2, -1]], "a[0]")
self.assertEqual(expected, ListElem("a", expression, 0).to_expression())
expression = Expression(Type.list_of(Type.boolean()), [True, False], "b[1]")
expected = Expression(Type.boolean(), False, "b[1][1]")
self.assertEqual(expected, ListElem("b[1]", expression, 1).to_expression())
def test_eq(self):
expressions1 = [None,
Expression(Type.int(), 1), Expression(Type.decimal(), 1.1), Expression(Type.boolean(), False),
Expression(Type.vector(), [1.1, 2.2, -1.1]), Expression(Type.list_of(Type.int()), [1, 2, 3, 4]),
Expression(Type.list_of(Type.int()), []),
Expression(Type.list_of(Type.decimal()), [1.0, 2.0, 3.0, 4.0]),
Expression(Type.list_of(Type.list_of(Type.vector())), [[[1.1, 2.2, -1.1], [1, 2, -1]]]),
Expression(Type.int(), 1, "a"), Expression(Type.decimal(), 1.1, "a"),
Expression(Type.boolean(), False, "a"),
Expression(Type.vector(), [1.1, 2.2, -1.1], "a"),
Expression(Type.list_of(Type.int()), [1, 2, 3, 4], "a"),
Expression(Type.list_of(Type.int()), [], "a"),
Expression(Type.list_of(Type.decimal()), [1.0, 2.0, 3.0, 4.0], "a"),
Expression(Type.list_of(Type.list_of(Type.vector())), [[[1.1, 2.2, -1.1], [1, 2, -1]]], "a")]
expressions2 = [None,
Expression(Type.int(), 1), Expression(Type.decimal(), 1.1), Expression(Type.boolean(), False),
Expression(Type.vector(), [1.1, 2.2, -1.1]), Expression(Type.list_of(Type.int()), [1, 2, 3, 4]),
Expression(Type.list_of(Type.int()), []),
Expression(Type.list_of(Type.decimal()), [1.0, 2.0, 3.0, 4.0]),
Expression(Type.list_of(Type.list_of(Type.vector())), [[[1.1, 2.2, -1.1], [1, 2, -1]]]),
Expression(Type.int(), 1, "a"), Expression(Type.decimal(), 1.1, "a"),
Expression(Type.boolean(), False, "a"),
Expression(Type.vector(), [1.1, 2.2, -1.1], "a"),
Expression(Type.list_of(Type.int()), [1, 2, 3, 4], "a"),
Expression(Type.list_of(Type.int()), [], "a"),
Expression(Type.list_of(Type.decimal()), [1.0, 2.0, 3.0, 4.0], "a"),
Expression(Type.list_of(Type.list_of(Type.vector())), [[[1.1, 2.2, -1.1], [1, 2, -1]]], "a")]
for i in range(len(expressions1)):
for j in range(len(expressions2)):
if i == j:
self.assertEqual(expressions1[i], expressions2[j])
else:
self.assertNotEqual(expressions1[i], expressions2[j])
def test_to_expression_should_equal_self(self):
expressions = [Expression(Type.int(), 1), Expression(Type.decimal(), 1.1), Expression(Type.boolean(), False),
Expression(Type.vector(), [1.1, 2.2, -1.1]), Expression(Type.list_of(Type.int()), [1, 2, 3, 4]),
Expression(Type.list_of(Type.int()), []),
Expression(Type.list_of(Type.decimal()), [1.0, 2.0, 3.0, 4.0]),
Expression(Type.list_of(Type.list_of(Type.vector())), [[[1.1, 2.2, -1.1], [1, 2, -1]]]),
Expression(Type.int(), 1, "a"), Expression(Type.decimal(), 1.1, "a"),
Expression(Type.boolean(), False, "a"),
Expression(Type.vector(), [1.1, 2.2, -1.1], "a"),
Expression(Type.list_of(Type.int()), [1, 2, 3, 4], "a"),
Expression(Type.list_of(Type.int()), [], "a"),
Expression(Type.list_of(Type.decimal()), [1.0, 2.0, 3.0, 4.0], "a"),
Expression(Type.list_of(Type.list_of(Type.vector())), [[[1.1, 2.2, -1.1], [1, 2, -1]]], "a")]
for expression in expressions:
self.assertEqual(expression, expression.to_expression())
def test_eq(self):
identifiers1 = [None, Identifier("a", None), Identifier("a", Expression(Type.int(), 1, "a")),
Identifier("a", Expression(Type.decimal(), 1.1, "a")),
Identifier("b", Expression(Type.int(), 1, "b")),
Identifier("b", Expression(Type.list_of(Type.int()), [], "b"))]
identifiers2 = [None, Identifier("a", None), Identifier("a", Expression(Type.int(), 1, "a")),
Identifier("a", Expression(Type.decimal(), 1.1, "a")),
Identifier("b", Expression(Type.int(), 1, "b")),
Identifier("b", Expression(Type.list_of(Type.int()), [], "b"))]
for i in range(len(identifiers1)):
for j in range(len(identifiers2)):
if i == j:
self.assertEqual(identifiers1[i], identifiers2[j])
else:
self.assertNotEqual(identifiers1[i], identifiers2[j])
def test_assign_list_elem_with_different_type_should_give_error(self):
types = [
Type.int(),
Type.decimal(),
Type.string(),
Type.boolean(),
Type.vector(),
Type.list_of(Type.int()),
Type.list_of(Type.list_of(Type.int()))
]
for t1 in types:
for t2 in types:
if t1 == t2:
continue
with self.assertRaises(CompileError) as context:
generate_commands("""
main () {{
{} a;
{} b;
list[{}] c <- [a];
c[0] <- b;
}}
""".format(t1, t2, t1))
self.assertTrue(
"Assigned value {} should have type {}, but is {}".format(
t2.default_value, t1.type_name, t2.type_name) in str(
context.exception))
def backward(self, children) -> List[Command]:
expr, = children
if expr.type != Type.int() and expr.type != Type.decimal():
raise CompileError(
"Expression {} should have type int or decimal, but is {}".
format(expr.value, expr.type))
return [Command.backward(expr.value)]
def test_str(self):
self.assertEqual("Expression: { type: int, value: 1, ident: None }", str(Expression(Type.int(), 1)))
self.assertEqual("Expression: { type: decimal, value: 1.1, ident: None }", str(Expression(Type.decimal(), 1.1)))
self.assertEqual("Expression: { type: boolean, value: False, ident: None }",
str(Expression(Type.boolean(), False)))
self.assertEqual("Expression: { type: vector, value: [1.1, 2.2, -1.1], ident: None }",
str(Expression(Type.vector(), [1.1, 2.2, -1.1])))
self.assertEqual("Expression: { type: list[int], value: [1, 2, 3, 4], ident: None }",
str(Expression(Type.list_of(Type.int()), [1, 2, 3, 4])))
self.assertEqual("Expression: { type: list[int], value: [], ident: None }",
str(Expression(Type.list_of(Type.int()), [])))
self.assertEqual(
"Expression: { type: list[list[vector]], value: [[[1.1, 2.2, -1.1], [1, 2, -1]]], ident: None }",
str(Expression(Type.list_of(Type.list_of(Type.vector())), [[[1.1, 2.2, -1.1], [1, 2, -1]]])))
self.assertEqual("Expression: { type: int, value: 1, ident: a }", str(Expression(Type.int(), 1, "a")))
self.assertEqual("Expression: { type: decimal, value: 1.1, ident: a }",
str(Expression(Type.decimal(), 1.1, "a")))
self.assertEqual("Expression: { type: boolean, value: False, ident: a }",
str(Expression(Type.boolean(), False, "a")))
self.assertEqual("Expression: { type: vector, value: [1.1, 2.2, -1.1], ident: a }",
str(Expression(Type.vector(), [1.1, 2.2, -1.1], "a")))
self.assertEqual("Expression: { type: list[int], value: [1, 2, 3, 4], ident: a }",
str(Expression(Type.list_of(Type.int()), [1, 2, 3, 4], "a")))
self.assertEqual("Expression: { type: list[int], value: [], ident: a }",
str(Expression(Type.list_of(Type.int()), [], "a")))
self.assertEqual("Expression: { type: list[list[vector]], value: [[[1.1, 2.2, -1.1], [1, 2, -1]]], ident: a }",
str(Expression(Type.list_of(Type.list_of(Type.vector())), [[[1.1, 2.2, -1.1], [1, 2, -1]]],
"a")))
def test_declare_and_assign_with_different_type_should_give_error(self):
types = [
Type.int(),
Type.decimal(),
Type.string(),
Type.boolean(),
Type.vector(),
Type.list_of(Type.int()),
Type.list_of(Type.list_of(Type.int()))
]
for t1 in types:
for t2 in types:
if t1 == t2:
continue
with self.assertRaises(CompileError) as context:
generate_commands("""
main () {{
{} a;
{} b <- a;
}}
""".format(t1, t2))
self.assertTrue(
"Identifier b has been declared as {}, but assigned as {}".
format(t2.type_name, t1.type_name) in str(
context.exception))
def rotate_right(self, children) -> List[Command]:
expr, = children
if expr.type != Type.int() and expr.type != Type.decimal():
raise CompileError(
"Expression {} should have type int or decimal, but is {}".
format(expr.value, expr.type))
return [Command.rotate_right(radians(expr.value))]
def vector(self, children) -> Expression:
expr1, expr2, expr3 = children
for expr in [expr1, expr2, expr3]:
if expr.type != Type.decimal():
raise CompileError(
"Expression {} should have type decimal, but is {}".format(
expr, expr.type))
return Expression(Type.vector(),
[expr1.value, expr2.value, expr3.value])
def test_declare_and_assign_decimal_should_change_symbol_table(self):
actual = SymbolTable()
generate_commands(
"""
main () { decimal a <- 1.0; }
""", actual)
expected = SymbolTable()
expected.store("a", Expression(Type.decimal(), 1.0, ident="a"))
self.assertEqual(expected, actual)
def assign_vector_elem(self, children) -> List[Command]:
vector_elem, expr = children
ident = vector_elem.ident
vector = vector_elem.container
index = vector_elem.index
if expr.type != Type.decimal():
raise CompileError(
"Assigned value {} should have type decimal, but is {}".format(
expr.value, expr.type))
self._update_nested_ident(ident, expr, index)
return []
def test_assign_ident_decimal_should_update_symbol_table(self):
actual = SymbolTable()
generate_commands(
"""
main () {
decimal a;
a <- -1.5e10;
}
""", actual)
expected = SymbolTable()
expected.store("a", Expression(Type.decimal(), -1.5e10, ident="a"))
self.assertEqual(expected, actual)
def test_eq(self):
list_elems1 = [None,
ListElem("a", Expression(Type.list_of(Type.decimal()), [1.0, 2.0, 3.0, 4.0], "a"), 0),
ListElem("b", Expression(Type.list_of(Type.decimal()), [1.0, 2.0, 3.0, 4.0], "b"), 0),
ListElem("a", Expression(Type.list_of(Type.decimal()), [1.0, 2.0, 3.0], "a"), 0),
ListElem("a", Expression(Type.list_of(Type.decimal()), [1.0, 2.0, 3.0, 4.0], "a"), 1),
ListElem("a", Expression(Type.list_of(Type.list_of(Type.int())), [[[1], [1]]], "a"), 0),
ListElem("b[1]", Expression(Type.list_of(Type.boolean()), [True, False], "b[1]"), 0)]
list_elems2 = [None,
ListElem("a", Expression(Type.list_of(Type.decimal()), [1.0, 2.0, 3.0, 4.0], "a"), 0),
ListElem("b", Expression(Type.list_of(Type.decimal()), [1.0, 2.0, 3.0, 4.0], "b"), 0),
ListElem("a", Expression(Type.list_of(Type.decimal()), [1.0, 2.0, 3.0], "a"), 0),
ListElem("a", Expression(Type.list_of(Type.decimal()), [1.0, 2.0, 3.0, 4.0], "a"), 1),
ListElem("a", Expression(Type.list_of(Type.list_of(Type.int())), [[[1], [1]]], "a"), 0),
ListElem("b[1]", Expression(Type.list_of(Type.boolean()), [True, False], "b[1]"), 0)]
for i in range(len(list_elems1)):
for j in range(len(list_elems2)):
if i == j:
self.assertEqual(list_elems1[i], list_elems2[j])
else:
self.assertNotEqual(list_elems1[i], list_elems2[j])
def test_declare_and_assign_ident_empty_list_should_update_symbol_table(
self):
types = [
Type.int(),
Type.decimal(),
Type.string(),
Type.boolean(),
Type.vector(),
Type.list_of(Type.int()),
Type.list_of(Type.list_of(Type.int()))
]
for type in types:
actual = SymbolTable()
generate_commands(
"""
main () {{
list[{}] a <- [];
}}
""".format(type.type_name), actual)
expected = SymbolTable()
expected.store("a", Expression(Type.list_of(type), [], ident="a"))
self.assertEqual(expected, actual)
def test_eq(self):
types1 = [
None,
Type.int(),
Type.decimal(),
Type.string(),
Type.boolean(),
Type.vector(),
Type.list_of(Type.int()),
Type.list_of(Type.decimal()),
Type.list_of(Type.list_of(Type.int())),
Type.list_of(Type.list_of(Type.decimal()))
]
types2 = [
None,
Type.int(),
Type.decimal(),
Type.string(),
Type.boolean(),
Type.vector(),
Type.list_of(Type.int()),
Type.list_of(Type.decimal()),
Type.list_of(Type.list_of(Type.int())),
Type.list_of(Type.list_of(Type.decimal()))
]
for i in range(len(types1)):
for j in range(len(types2)):
if i == j:
self.assertEqual(types1[i], types2[j])
else:
self.assertNotEqual(types1[i], types2[j])
self.assertEqual(Type.empty_list(), Type.empty_list())
for type in types1:
if isinstance(type, ListType):
self.assertEqual(Type.empty_list(), type)
self.assertEqual(type, Type.empty_list())
else:
self.assertNotEqual(Type.empty_list(), type)
self.assertNotEqual(type, Type.empty_list())
def test_decimal(self):
self.assertEqual(Type.decimal(), Type.decimal())
self.assertEqual("decimal", Type.decimal().type_name)
self.assertEqual(0.0, Type.decimal().default_value)
self.assertEqual("decimal", str(Type.decimal()))
def __init__(self, ident: str, container: Expression, index: int):
assert container.type == Type.vector()
self._ident = ident
self._container = container
self._index = index
self._expression = Expression(Type.decimal(), container.value[index])
def decimal_type(self, children) -> Type:
return Type.decimal()
def decimal_expr(self, children) -> Expression:
signed_float, = children
return Expression(Type.decimal(), float(signed_float))
