def test_array_initializer_no_errors(self):
tokens_list = [
Token("assignment", "", 1),
Token("left_brace", "", 1),
Token("number", 1, 1),
Token("comma", "", 1),
Token("number", 2, 1),
Token("right_brace", "", 1),
]
table = SymbolTable()
table.entry("1", "int", "variable")
table.entry("2", "int", "variable")
op_value, op_type, i = array_initializer(
tokens=tokens_list,
i=1,
table=table,
size_of_array=2,
msg="Test message",
func_ret_type={},
)
self.assertEqual(op_value, "{1,2")
self.assertEqual(op_type, 3)
def test_switch_statement_missing_right_paren(self):
tokens_list = [
Token("switch", "", 1),
Token("left_paren", "", 1),
Token("print", "", 1),
]
table = SymbolTable()
self.__suppress_print()
with self.assertRaises(SystemExit):
_, _, _ = switch_statement(
tokens=tokens_list, i=1, table=table, func_ret_type={}
)
self.__release_print()
def __test_error_case(self, tokens_list, table=None):
if table == None:
table = SymbolTable()
self.__suppress_print()
with self.assertRaises(SystemExit):
_, _, _ = array_initializer(
tokens=tokens_list,
i=1,
table=table,
size_of_array=2,
msg="Test message",
)
self.__release_print()
def test_lexical_analyze_left_right_paren_call_end(self):
# Test left_paren, right_paren, and call_end
source_code = "var a = (1)"
with open("testing.simc", "w") as file:
file.write(source_code)
table = SymbolTable()
tokens = lexical_analyze("testing.simc", table)
left_paren = Token("left_paren", "", 1)
right_paren = Token("right_paren", "", 1)
call_end = Token("call_end", "", 1)
self.assertEqual(tokens[3], left_paren)
self.assertEqual(tokens[5], right_paren)
def test_lexical_analyze_assignment_equal(self):
# Test assignment and equal
source_code = "var a = 1 == 1"
with open("testing.simc", "w") as file:
file.write(source_code)
table = SymbolTable()
tokens = lexical_analyze("testing.simc", table)
assignment = Token("assignment", "", 1)
equal = Token("equal", "", 1)
self.assertEqual(tokens[2], assignment)
self.assertEqual(tokens[-2], equal)
def test_lexical_analyze_multiply_equal_multiply(self):
# Test multiply_equal and multiply
source_code = """var a = 1 * 2
a *= 1
"""
with open("testing.simc", "w") as file:
file.write(source_code)
table = SymbolTable()
tokens = lexical_analyze("testing.simc", table)
multiply_equal = Token("multiply_equal", "", 2)
multiply = Token("multiply", "", 1)
self.assertEqual(tokens[8], multiply_equal)
self.assertEqual(tokens[4], multiply)
def test_lexical_analyze_modulus_equal_modulus(self):
# Test modulus_equal and modulus
source_code = """var a = 1 % 2
a %= 3
"""
with open("testing.simc", "w") as file:
file.write(source_code)
table = SymbolTable()
tokens = lexical_analyze("testing.simc", table)
modulus_equal = Token("modulus_equal", "", 2)
modulus = Token("modulus", "", 1)
self.assertEqual(tokens[8], modulus_equal)
self.assertEqual(tokens[4], modulus)
def test_array_initializer_cannot_find_type(self):
tokens_list = [
Token("assignment", "", 1),
Token("left_brace", "", 1),
Token("number", 1, 1),
Token("comma", "", 1),
Token("number", 2, 1),
Token("right_brace", "", 1),
]
table = SymbolTable()
table.entry("1", "var", "variable")
table.entry("3.14", "var", "variable")
self.__test_error_case(tokens_list, table)
def test_lexical_analyze_left_right_brace_newline(self):
# Test left_brace, right_brace, and newline
source_code = """if(1 == 1) {
print(1)
}
"""
with open("testing.simc", "w") as file:
file.write(source_code)
table = SymbolTable()
tokens = lexical_analyze("testing.simc", table)
left_brace = Token("left_brace", "", 1)
right_brace = Token("right_brace", "", 3)
newline = Token("newline", "", 1)
self.assertEqual(tokens[7], left_brace)
self.assertEqual(tokens[-2], right_brace)
self.assertEqual(tokens[8], newline)
def test_for_statement_missing_by_keyword(self):
tokens_list = [
Token("for", "", 1),
Token("id", 1, 1),
Token("in", "", 1),
Token("number", 2, 1),
Token("to", "", 1),
Token("number", 3, 1),
Token("print", "", 1),
]
table = SymbolTable()
table.entry("a", "int", "variable")
table.entry("1", "int", "variable")
table.entry("10", "int", "variable")
self.__test_error_case(tokens_list, table=table)
def test_lexical_analyze_minus_equal_decrement_minus(self):
# Test minus_equal, decrement, and minus
source_code = """var a = 1 - 2
a -= 1
a--
"""
with open("testing.simc", "w") as file:
file.write(source_code)
table = SymbolTable()
tokens = lexical_analyze("testing.simc", table)
minus_equal = Token("minus_equal", "", 2)
decrement = Token("decrement", "", 3)
minus = Token("minus", "", 1)
self.assertEqual(tokens[8], minus_equal)
self.assertEqual(tokens[12], decrement)
self.assertEqual(tokens[4], minus)
def test_lexical_analyze_less_than_less_than_equal_left_shift(self):
# Test less_than, less_than_equal, left_shift
source_code = """1 < 2
1 <= 2
1 << 2
"""
with open("testing.simc", "w") as file:
file.write(source_code)
table = SymbolTable()
tokens = lexical_analyze("testing.simc", table)
less_than = Token("less_than", "", 1)
less_than_equal = Token("less_than_equal", "", 2)
left_shift = Token("left_shift", "", 3)
self.assertEqual(tokens[1], less_than)
self.assertEqual(tokens[5], less_than_equal)
self.assertEqual(tokens[9], left_shift)
def test_lexical_analyze_greater_than_greater_than_equal_right_shift(self):
# Test greater_than, greater_than_equal, right_shift
source_code = """1 > 2
1 >= 2
1 >> 2
"""
with open("testing.simc", "w") as file:
file.write(source_code)
table = SymbolTable()
tokens = lexical_analyze("testing.simc", table)
greater_than = Token("greater_than", "", 1)
greater_than_equal = Token("greater_than_equal", "", 2)
right_shift = Token("right_shift", "", 3)
self.assertEqual(tokens[1], greater_than)
self.assertEqual(tokens[5], greater_than_equal)
self.assertEqual(tokens[9], right_shift)
def test_lexical_analyze_plus_equal_increment_plus(self):
# Test plus_equal, increment, and plus
source_code = """var a = 1 + 2
a += 1
a++
"""
with open("testing.simc", "w") as file:
file.write(source_code)
table = SymbolTable()
tokens = lexical_analyze("testing.simc", table)
plus_equal = Token("plus_equal", "", 2)
increment = Token("increment", "", 3)
plus = Token("plus", "", 1)
self.assertEqual(tokens[8], plus_equal)
self.assertEqual(tokens[12], increment)
self.assertEqual(tokens[4], plus)
def test_for_statement_no_errors(self):
tokens_list = [
Token("for", "", 1),
Token("id", 1, 1),
Token("in", "", 1),
Token("number", 2, 1),
Token("to", "", 1),
Token("number", 3, 1),
Token("by", "", 1),
Token("plus", "", 1),
Token("number", 4, 1),
]
table = SymbolTable()
table.entry("a", "int", "variable")
table.entry("1", "int", "variable")
table.entry("10", "int", "variable")
table.entry("2", "int", "variable")
opcode, _, _ = for_statement(tokens=tokens_list,
i=1,
table=table,
func_ret_type={})
self.assertEqual(opcode, OpCode("for", "a&&&1&&&10&&&+&&&<&&&2", None))
def test_array_initializer_number_of_entries_do_not_match(self):
tokens_list = [
Token("assignment", "", 1),
Token("left_brace", "", 1),
Token("number", 1, 1),
Token("comma", "", 1),
Token("number", 2, 1),
Token("comma", "", 1),
Token("number", 2, 1),
Token("right_brace", "", 1),
]
table = SymbolTable()
table.entry("1", "int", "variable")
table.entry("3", "int", "variable")
table.entry("4", "int", "variable")
self.__test_error_case(tokens_list, table)
def test_structure_declaration_no_error(self):
tokens_list = [
Token("struct", "", 1),
Token("id", 1, 1),
Token("left_brace", "", 1),
Token("newline", "", 1),
Token("var", "", 2),
Token("id", 2, 2),
Token("assignment", "", 2),
Token("number", 3, 2),
Token("newline", "", 2),
Token("right_brace", "", 3),
Token("newline", "", 3),
]
table = SymbolTable()
table.entry("my_struct", "var", "variable")
table.entry("a", "int", "variable")
table.entry("a", "int", "constant")
opcode, _, _ = struct_declaration_statement(tokens=tokens_list,
i=1,
table=table)
self.assertEqual(opcode, OpCode("struct_decl", "my_struct", ""))
def setUp(self):
self.table = SymbolTable()
