def test_assess_list_elem_nested_out_of_bound_should_give_error(self): with self.assertRaises(CompileError) as context: generate_commands(""" main () { list[list[list[int]]] a <- [[[1], [2]]]; a[0][2] <- [1]; } """) self.assertTrue( "List {} has length 2, but has been assessed with out-of-range index 2" .format( Expression(Type.list_of(Type.list_of(Type.int())), [[1], [2]], ident="a[0]")) in str(context.exception)) with self.assertRaises(CompileError) as context: generate_commands(""" main () { list[list[list[int]]] a <- [[[1], [2]]]; a[0][1][1] <- 1; } """) self.assertTrue( "List {} has length 1, but has been assessed with out-of-range index 1" .format(Expression(Type.list_of(Type.int()), [2], ident="a[0][1]")) in str(context.exception))
def test_list_elem_expr_out_of_range_should_give_error(self): with self.assertRaises(CompileError) as context: generate_commands(""" main () {{ list[int] a <- [1, 2]; int b <- a[2]; }} """.format(type)) self.assertTrue( "List {} has length {}, but has been assessed with out-of-range index {}" .format(Expression(Type.list_of(Type.int()), [1, 2], ident="a"), 2, 2) in str(context.exception)) with self.assertRaises(CompileError) as context: generate_commands(""" main () {{ list[int] a <- [1, 2]; int b <- a[-1]; }} """.format(type)) self.assertTrue( "List {} has length {}, but has been assessed with out-of-range index {}" .format(Expression(Type.list_of(Type.int()), [1, 2], ident="a"), 2, -1) in str(context.exception))
def test_eq(self): vector_elems1 = [ None, VectorElem("a", Expression(Type.vector(), [1.0, 2.0, 3.0], "a"), 0), VectorElem("b", Expression(Type.vector(), [1.0, 2.0, 3.0], "b"), 0), VectorElem("a", Expression(Type.vector(), [2.0, 2.0, 3.0], "a"), 0), VectorElem("a", Expression(Type.vector(), [1.0, 2.0, 3.0], "a"), 1), VectorElem("b[1]", Expression(Type.vector(), [1.0, 2.0, 3.0], "a"), 0) ] vector_elems2 = [ None, VectorElem("a", Expression(Type.vector(), [1.0, 2.0, 3.0], "a"), 0), VectorElem("b", Expression(Type.vector(), [1.0, 2.0, 3.0], "b"), 0), VectorElem("a", Expression(Type.vector(), [2.0, 2.0, 3.0], "a"), 0), VectorElem("a", Expression(Type.vector(), [1.0, 2.0, 3.0], "a"), 1), VectorElem("b[1]", Expression(Type.vector(), [1.0, 2.0, 3.0], "a"), 0) ] for i in range(len(vector_elems1)): for j in range(len(vector_elems2)): if i == j: self.assertEqual(vector_elems1[i], vector_elems2[j]) else: self.assertNotEqual(vector_elems1[i], vector_elems2[j])
def test_store(self): st = SymbolTable() st.store("a", Expression(Type.int(), 1)) self.assertTrue("a" in st) self.assertEqual(Type.int(), st.get_expression("a").type) self.assertEqual(1, st.get_expression("a").value) self.assertRaises(AssertionError, st.store, "a", Expression(Type.int(), 1))
def test_str(self): st = SymbolTable() st.store("a", Expression(Type.int(), 0)) st.store("b", Expression(Type.list_of(Type.boolean()), [True])) expected = "SymbolTable: {\n" + \ " a -> Expression: { type: int, value: 0, ident: None }\n" + \ " b -> Expression: { type: list[boolean], value: [True], ident: None }\n" + \ "}" self.assertEqual(expected, str(st))
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_eq(self): st1 = SymbolTable() st2 = SymbolTable() self.assertTrue(st1 == st2) st1.store("a", Expression(Type.int(), 0)) self.assertFalse(st1 == st2) st2.store("a", Expression(Type.int(), 0)) self.assertTrue(st1 == st2) self.assertNotEqual(SymbolTable(), None)
def visitList(self, ctx: xDroneParser.ListContext) -> Expression: exprs = [self.visit(expr) for expr in ctx.expr()] if len(exprs) == 0: return Expression(Type.empty_list(), []) if not all(e.type == exprs[0].type for e in exprs): raise CompileError( "Elements in list {} should have the same type".format( [str(e) for e in exprs])) return Expression(Type.list_of(exprs[0].type), [e.value for e in exprs])
def test_list_with_inconsistent_type_should_give_error(self): with self.assertRaises(CompileError) as context: generate_commands(""" main () { list[int] a <- [1, 1.0]; } """) self.assertTrue( "Elements in list {} should have the same type".format([ str(Expression(Type.int(), 1, None)), str(Expression(Type.decimal(), 1.0, None)) ]) in str(context.exception))
def visitInsert(self, ctx: xDroneParser.InsertContext) -> None: list = self.visit(ctx.expr(0)) if not isinstance(list.type, ListType): raise CompileError( "Expression {} should have type list, but is {}".format( list, list.type)) if ctx.AT(): index = self.visit(ctx.expr(1)) value = self.visit(ctx.expr(2)) else: index = Expression(Type.int(), len(list.value)) value = self.visit(ctx.expr(1)) if index.type != Type.int(): raise CompileError( "Expression {} should have type int, but is {}".format( index, index.type)) if index.value > len(list.value) or index.value < 0: raise CompileError( "List {} has length {}, but has been inserted at out-of-range index {}" .format(list, len(list.value), index.value)) if not isinstance(list.type, EmptyList) and value.type != list.type.elem_type: raise CompileError( "List {} has been declared as {}, but inserted with element type {}" .format(list, list.type, value.type)) self._insert_nested_ident(list.ident, value, index.value)
def test_list_elem_assign_with_wrong_index_should_give_error(self): types = [ Type.decimal(), Type.string(), Type.boolean(), Type.vector(), Type.drone(), Type.list_of(Type.int()), Type.list_of(Type.decimal()), Type.list_of(Type.list_of(Type.int())) ] for type in types: with self.assertRaises(CompileError) as context: generate_commands(""" main () {{ {} a; list[int] b; b[a] <- 1; }} """.format(type)) self.assertTrue( "Expression {} should have type int, but is {}".format( Expression(type, type.default_value, ident="a"), type.type_name) in str(context.exception))
def test_list_insert_with_wrong_type_value_should_give_error(self): types = [ Type.int(), Type.decimal(), Type.string(), Type.boolean(), Type.vector(), Type.drone(), Type.list_of(Type.int()), Type.list_of(Type.decimal()), 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; list[{}] b; b.insert(a); }} """.format(t1, t2)) self.assertTrue( "List {} has been declared as {}, but inserted with element type {}" .format(Expression(Type.list_of(t2), [], ident="b"), Type.list_of(t2), t1) in str(context.exception))
def visitSize(self, ctx: xDroneParser.SizeContext) -> Expression: expr = self.visit(ctx.expr()) if not isinstance(expr.type, ListType): raise CompileError( "Expression {} should have type list, but is {}".format( expr, expr.type)) return Expression(Type.int(), len(expr.value))
def test_list_should_return_correct_value(self): actual = SymbolTable() generate_commands(""" main () { list[int] a <- []; list[boolean] b <- [true, false]; } """, symbol_table=actual) expected = SymbolTable() expected.store("a", Expression(Type.list_of(Type.int()), [], ident="a")) expected.store( "b", Expression(Type.list_of(Type.boolean()), [True, False], ident="b")) self.assertEqual(expected, actual)
def visitPlusMinus(self, ctx: xDroneParser.PlusMinusContext) -> Expression: expr1, expr2 = self.visit(ctx.expr(0)), self.visit(ctx.expr(1)) if self._is_int_or_decimal(expr1.type) and self._is_int_or_decimal( expr2.type): result_type, func = self._get_int_decimal_result_type( expr1.type, expr2.type) if ctx.PLUS(): result_value = func(expr1.value + expr2.value) else: # MINUS result_value = func(expr1.value - expr2.value) elif expr1.type == Type.vector() and expr2.type == Type.vector(): result_type = Type.vector() if ctx.PLUS(): result_value = [ e1 + e2 for e1, e2 in zip(expr1.value, expr2.value) ] else: # MINUS result_value = [ e1 - e2 for e1, e2 in zip(expr1.value, expr2.value) ] else: raise CompileError( "Expression {} and {} have wrong types to perform addition or subtraction" .format(expr1, expr2)) return Expression(result_type, result_value)
def visitMultiDivide(self, ctx: xDroneParser.MultiDivideContext) -> Expression: expr1, expr2 = self.visit(ctx.expr(0)), self.visit(ctx.expr(1)) if self._is_int_or_decimal(expr1.type) and self._is_int_or_decimal( expr2.type): result_type, func = self._get_int_decimal_result_type( expr1.type, expr2.type) if ctx.MULTI(): result_value = func(expr1.value * expr2.value) else: # DIV if expr2.value == 0: raise CompileError("Division by zero") result_value = func(expr1.value / expr2.value) elif self._is_int_or_decimal( expr1.type) and expr2.type == Type.vector(): result_type = Type.vector() if ctx.MULTI(): result_value = [expr1.value * e for e in expr2.value] else: # DIV raise CompileError( "Expression {} and {} have wrong types to perform multiplication or division" .format(expr1, expr2)) elif expr1.type == Type.vector() and self._is_int_or_decimal( expr2.type): result_type = Type.vector() if ctx.MULTI(): result_value = [e * expr2.value for e in expr1.value] else: # DIV result_value = [e / expr2.value for e in expr1.value] else: raise CompileError( "Expression {} and {} have wrong types to perform multiplication or division" .format(expr1, expr2)) return Expression(result_type, result_value)
def visitNot(self, ctx: xDroneParser.NotContext) -> Expression: expr = self.visit(ctx.expr()) if expr.type != Type.boolean(): raise CompileError( "Expression {} should have type boolean, but is {}".format( expr, expr.type)) return Expression(Type.boolean(), not expr.value)
def test_get_expression(self): st = SymbolTable() self.assertRaises(AssertionError, st.get_expression, "a") st.store("a", Expression(Type.list_of(Type.int()), [1])) self.assertEqual([1], st.get_expression("a").value) self.assertEqual(1, st.get_expression("a").value[0]) self.assertEqual(Type.list_of(Type.int()), st.get_expression("a").type)
def visitDeclare(self, ctx: xDroneParser.DeclareContext) -> None: type, identifier = self.visit(ctx.type_()), self.visit(ctx.ident()) ident = identifier.ident if ident in self._get_latest_symbol_table() or ident in self.drones: raise CompileError("Identifier {} already declared".format(ident)) self._get_latest_symbol_table().store( ident, Expression(type, type.default_value, ident=ident))
def test_assign_list_elem_with_different_type_should_give_error(self): types = [ Type.int(), Type.decimal(), Type.string(), Type.boolean(), Type.vector(), Type.drone(), 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( Expression(t2, t2.default_value, ident="b"), t1.type_name, t2.type_name) in str(context.exception))
def test_update(self): st = SymbolTable() self.assertRaises(AssertionError, st.update, "a", 1) st.store("a", Expression(Type.int(), 1)) st.update("a", 2) self.assertEqual(Type.int(), st.get_expression("a").type) self.assertEqual(2, st.get_expression("a").value)
def test_list_elem_expr_should_return_correct_value(self): actual = SymbolTable() generate_commands(""" main () { list[int] a <- [1, 2, 3]; int b <- a[0]; int c <- a[1]; int d <- a[2]; } """, symbol_table=actual) expected = SymbolTable() expected.store( "a", Expression(Type.list_of(Type.int()), [1, 2, 3], ident="a")) expected.store("b", Expression(Type.int(), 1, ident="b")) expected.store("c", Expression(Type.int(), 2, ident="c")) expected.store("d", Expression(Type.int(), 3, ident="d")) self.assertEqual(expected, actual)
def test_vector_elem_expr_should_return_correct_value(self): actual = SymbolTable() generate_commands(""" main () { vector a <- (1, -2, -3.0); decimal b <- a.x; decimal c <- a.y; decimal d <- a.z; } """, symbol_table=actual) expected = SymbolTable() expected.store("a", Expression(Type.vector(), [1.0, -2.0, -3.0], ident="a")) expected.store("b", Expression(Type.decimal(), 1.0, ident="b")) expected.store("c", Expression(Type.decimal(), -2.0, ident="c")) expected.store("d", Expression(Type.decimal(), -3.0, ident="d")) self.assertEqual(expected, actual)
def test_for_should_keep_updates_but_discard_new_variables(self): actual = SymbolTable() actual_commands = generate_commands(""" main () { int a <- 0; int i <- 1; for i from 1 to 5 { int b <- 1; a <- a + 1; } } """, symbol_table=actual) expected = SymbolTable() expected.store("a", Expression(Type.int(), 5, ident="a")) expected.store("i", Expression(Type.int(), 5, ident="i")) self.assertEqual(expected, actual) expected_commands = [] self.assertEqual(expected_commands, actual_commands)
def test_declare_and_assign_vector_should_change_symbol_table(self): actual = SymbolTable() generate_commands(""" main () { vector a <- (1.0, 2.0, -3.0); } """, symbol_table=actual) expected = SymbolTable() expected.store("a", Expression(Type.vector(), [1, 2, -3], ident="a")) self.assertEqual(expected, actual)
def test_declare_and_assign_boolean_should_change_symbol_table(self): actual = SymbolTable() generate_commands(""" main () { boolean a <- true; } """, symbol_table=actual) expected = SymbolTable() expected.store("a", Expression(Type.boolean(), True, ident="a")) self.assertEqual(expected, actual)
def test_declare_and_assign_string_should_change_symbol_table(self): actual = SymbolTable() generate_commands(""" main () { string a <- "\0a"; } """, symbol_table=actual) expected = SymbolTable() expected.store("a", Expression(Type.string(), "\0a", ident="a")) self.assertEqual(expected, actual)
def test_declare_and_assign_decimal_should_change_symbol_table(self): actual = SymbolTable() generate_commands(""" main () { decimal a <- 1.0; } """, symbol_table=actual) expected = SymbolTable() expected.store("a", Expression(Type.decimal(), 1.0, ident="a")) self.assertEqual(expected, actual)
def test_declare_drone_should_change_symbol_table(self): actual = SymbolTable() generate_commands(""" main () { drone a; } """, symbol_table=actual) expected = SymbolTable() expected.store("a", Expression(Type.drone(), NullDrone(), ident="a")) self.assertEqual(expected, actual)
def test_str(self): self.assertEqual( "ListElem: { ident: a, " + "container: Expression: { type: vector, value: [1.0, 2.0, 3.0], ident: a }, " + "index: 0, expression: Expression: { type: decimal, value: 1.0, ident: None } }", str( VectorElem("a", Expression(Type.vector(), [1.0, 2.0, 3.0], "a"), 0)))