| # Copyright 2019 Google LLC |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # https://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| """Tests for dependency_checker.py.""" |
| |
| import unittest |
| from compiler.front_end import dependency_checker |
| from compiler.front_end import glue |
| from compiler.util import error |
| from compiler.util import test_util |
| |
| |
| def _parse_snippet(emb_file): |
| ir, unused_debug_info, errors = glue.parse_emboss_file( |
| "m.emb", |
| test_util.dict_file_reader({"m.emb": emb_file}), |
| stop_before_step="find_dependency_cycles") |
| assert not errors |
| return ir |
| |
| |
| def _find_dependencies_for_snippet(emb_file): |
| ir, unused_debug_info, errors = glue.parse_emboss_file( |
| "m.emb", |
| test_util.dict_file_reader({ |
| "m.emb": emb_file |
| }), |
| stop_before_step="set_dependency_order") |
| assert not errors, errors |
| return ir |
| |
| |
| class DependencyCheckerTest(unittest.TestCase): |
| |
| def test_error_on_simple_field_cycle(self): |
| ir = _parse_snippet("struct Foo:\n" |
| " 0 [+field2] UInt field1\n" |
| " 0 [+field1] UInt field2\n") |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([[ |
| error.error("m.emb", struct.field[0].source_location, |
| "Dependency cycle\nfield1"), |
| error.note("m.emb", struct.field[1].source_location, "field2") |
| ]], dependency_checker.find_dependency_cycles(ir)) |
| |
| def test_error_on_self_cycle(self): |
| ir = _parse_snippet("struct Foo:\n" |
| " 0 [+field1] UInt field1\n") |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([[ |
| error.error("m.emb", struct.field[0].source_location, |
| "Dependency cycle\nfield1") |
| ]], dependency_checker.find_dependency_cycles(ir)) |
| |
| def test_error_on_triple_field_cycle(self): |
| ir = _parse_snippet("struct Foo:\n" |
| " 0 [+field2] UInt field1\n" |
| " 0 [+field3] UInt field2\n" |
| " 0 [+field1] UInt field3\n") |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([[ |
| error.error("m.emb", struct.field[0].source_location, |
| "Dependency cycle\nfield1"), |
| error.note("m.emb", struct.field[1].source_location, "field2"), |
| error.note("m.emb", struct.field[2].source_location, "field3"), |
| ]], dependency_checker.find_dependency_cycles(ir)) |
| |
| def test_error_on_complex_field_cycle(self): |
| ir = _parse_snippet("struct Foo:\n" |
| " 0 [+field2] UInt field1\n" |
| " 0 [+field3+field4] UInt field2\n" |
| " 0 [+field1] UInt field3\n" |
| " 0 [+field2] UInt field4\n") |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([[ |
| error.error("m.emb", struct.field[0].source_location, |
| "Dependency cycle\nfield1"), |
| error.note("m.emb", struct.field[1].source_location, "field2"), |
| error.note("m.emb", struct.field[2].source_location, "field3"), |
| error.note("m.emb", struct.field[3].source_location, "field4"), |
| ]], dependency_checker.find_dependency_cycles(ir)) |
| |
| def test_error_on_simple_enum_value_cycle(self): |
| ir = _parse_snippet("enum Foo:\n" |
| " XX = YY\n" |
| " YY = XX\n") |
| enum = ir.module[0].type[0].enumeration |
| self.assertEqual([[ |
| error.error("m.emb", enum.value[0].source_location, |
| "Dependency cycle\nXX"), |
| error.note("m.emb", enum.value[1].source_location, "YY") |
| ]], dependency_checker.find_dependency_cycles(ir)) |
| |
| def test_no_error_on_no_cycle(self): |
| ir = _parse_snippet("enum Foo:\n" |
| " XX = 0\n" |
| " YY = XX\n") |
| self.assertEqual([], dependency_checker.find_dependency_cycles(ir)) |
| |
| def test_error_on_cycle_nested(self): |
| ir = _parse_snippet("struct Foo:\n" |
| " struct Bar:\n" |
| " 0 [+field2] UInt field1\n" |
| " 0 [+field1] UInt field2\n" |
| " 0 [+1] UInt field\n") |
| struct = ir.module[0].type[0].subtype[0].structure |
| self.assertEqual([[ |
| error.error("m.emb", struct.field[0].source_location, |
| "Dependency cycle\nfield1"), |
| error.note("m.emb", struct.field[1].source_location, "field2") |
| ]], dependency_checker.find_dependency_cycles(ir)) |
| |
| def test_error_on_import_cycle(self): |
| ir, unused_debug_info, errors = glue.parse_emboss_file( |
| "m.emb", |
| test_util.dict_file_reader({"m.emb": 'import "n.emb" as n\n', |
| "n.emb": 'import "m.emb" as m\n'}), |
| stop_before_step="find_dependency_cycles") |
| assert not errors |
| self.assertEqual([[ |
| error.error("m.emb", ir.module[0].source_location, |
| "Import dependency cycle\nm.emb"), |
| error.note("n.emb", ir.module[2].source_location, "n.emb") |
| ]], dependency_checker.find_dependency_cycles(ir)) |
| |
| def test_error_on_import_cycle_and_field_cycle(self): |
| ir, unused_debug_info, errors = glue.parse_emboss_file( |
| "m.emb", |
| test_util.dict_file_reader({"m.emb": 'import "n.emb" as n\n' |
| "struct Foo:\n" |
| " 0 [+field1] UInt field1\n", |
| "n.emb": 'import "m.emb" as m\n'}), |
| stop_before_step="find_dependency_cycles") |
| assert not errors |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([[ |
| error.error("m.emb", ir.module[0].source_location, |
| "Import dependency cycle\nm.emb"), |
| error.note("n.emb", ir.module[2].source_location, "n.emb") |
| ], [ |
| error.error("m.emb", struct.field[0].source_location, |
| "Dependency cycle\nfield1") |
| ]], dependency_checker.find_dependency_cycles(ir)) |
| |
| def test_error_on_field_existence_self_cycle(self): |
| ir = _parse_snippet("struct Foo:\n" |
| " if x == 1:\n" |
| " 0 [+1] UInt x\n") |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([[ |
| error.error("m.emb", struct.field[0].source_location, |
| "Dependency cycle\nx") |
| ]], dependency_checker.find_dependency_cycles(ir)) |
| |
| def test_error_on_field_existence_cycle(self): |
| ir = _parse_snippet("struct Foo:\n" |
| " if y == 1:\n" |
| " 0 [+1] UInt x\n" |
| " if x == 0:\n" |
| " 1 [+1] UInt y\n") |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([[ |
| error.error("m.emb", struct.field[0].source_location, |
| "Dependency cycle\nx"), |
| error.note("m.emb", struct.field[1].source_location, "y") |
| ]], dependency_checker.find_dependency_cycles(ir)) |
| |
| def test_error_on_virtual_field_cycle(self): |
| ir = _parse_snippet("struct Foo:\n" |
| " let x = y\n" |
| " let y = x\n") |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([[ |
| error.error("m.emb", struct.field[0].source_location, |
| "Dependency cycle\nx"), |
| error.note("m.emb", struct.field[1].source_location, "y") |
| ]], dependency_checker.find_dependency_cycles(ir)) |
| |
| def test_error_on_virtual_non_virtual_field_cycle(self): |
| ir = _parse_snippet("struct Foo:\n" |
| " let x = y\n" |
| " x [+4] UInt y\n") |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([[ |
| error.error("m.emb", struct.field[0].source_location, |
| "Dependency cycle\nx"), |
| error.note("m.emb", struct.field[1].source_location, "y") |
| ]], dependency_checker.find_dependency_cycles(ir)) |
| |
| def test_error_on_non_virtual_virtual_field_cycle(self): |
| ir = _parse_snippet("struct Foo:\n" |
| " y [+4] UInt x\n" |
| " let y = x\n") |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([[ |
| error.error("m.emb", struct.field[0].source_location, |
| "Dependency cycle\nx"), |
| error.note("m.emb", struct.field[1].source_location, "y") |
| ]], dependency_checker.find_dependency_cycles(ir)) |
| |
| def test_error_on_cycle_involving_subfield(self): |
| ir = _parse_snippet("struct Bar:\n" |
| " foo_b.x [+4] Foo foo_a\n" |
| " foo_a.x [+4] Foo foo_b\n" |
| "struct Foo:\n" |
| " 0 [+4] UInt x\n") |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([[ |
| error.error("m.emb", struct.field[0].source_location, |
| "Dependency cycle\nfoo_a"), |
| error.note("m.emb", struct.field[1].source_location, "foo_b") |
| ]], dependency_checker.find_dependency_cycles(ir)) |
| |
| def test_dependency_ordering_with_no_dependencies(self): |
| ir = _find_dependencies_for_snippet("struct Foo:\n" |
| " 0 [+4] UInt a\n" |
| " 4 [+4] UInt b\n") |
| self.assertEqual([], dependency_checker.set_dependency_order(ir)) |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([0, 1], struct.fields_in_dependency_order[:2]) |
| |
| def test_dependency_ordering_with_dependency_in_order(self): |
| ir = _find_dependencies_for_snippet("struct Foo:\n" |
| " 0 [+4] UInt a\n" |
| " a [+4] UInt b\n") |
| self.assertEqual([], dependency_checker.set_dependency_order(ir)) |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([0, 1], struct.fields_in_dependency_order[:2]) |
| |
| def test_dependency_ordering_with_dependency_in_reverse_order(self): |
| ir = _find_dependencies_for_snippet("struct Foo:\n" |
| " b [+4] UInt a\n" |
| " 0 [+4] UInt b\n") |
| self.assertEqual([], dependency_checker.set_dependency_order(ir)) |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([1, 0], struct.fields_in_dependency_order[:2]) |
| |
| def test_dependency_ordering_with_extra_fields(self): |
| ir = _find_dependencies_for_snippet("struct Foo:\n" |
| " d [+4] UInt a\n" |
| " 4 [+4] UInt b\n" |
| " 8 [+4] UInt c\n" |
| " 12 [+4] UInt d\n") |
| self.assertEqual([], dependency_checker.set_dependency_order(ir)) |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([1, 2, 3, 0], struct.fields_in_dependency_order[:4]) |
| |
| def test_dependency_ordering_scrambled(self): |
| ir = _find_dependencies_for_snippet("struct Foo:\n" |
| " d [+4] UInt a\n" |
| " c [+4] UInt b\n" |
| " a [+4] UInt c\n" |
| " 12 [+4] UInt d\n") |
| self.assertEqual([], dependency_checker.set_dependency_order(ir)) |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([3, 0, 2, 1], struct.fields_in_dependency_order[:4]) |
| |
| def test_dependency_ordering_multiple_dependents(self): |
| ir = _find_dependencies_for_snippet("struct Foo:\n" |
| " d [+4] UInt a\n" |
| " d [+4] UInt b\n" |
| " d [+4] UInt c\n" |
| " 12 [+4] UInt d\n") |
| self.assertEqual([], dependency_checker.set_dependency_order(ir)) |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([3, 0, 1, 2], struct.fields_in_dependency_order[:4]) |
| |
| def test_dependency_ordering_multiple_dependencies(self): |
| ir = _find_dependencies_for_snippet("struct Foo:\n" |
| " b+c [+4] UInt a\n" |
| " 4 [+4] UInt b\n" |
| " 8 [+4] UInt c\n" |
| " a [+4] UInt d\n") |
| self.assertEqual([], dependency_checker.set_dependency_order(ir)) |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([1, 2, 0, 3], struct.fields_in_dependency_order[:4]) |
| |
| def test_dependency_ordering_with_parameter(self): |
| ir = _find_dependencies_for_snippet("struct Foo:\n" |
| " 0 [+1] Bar(x) b\n" |
| " 1 [+1] UInt x\n" |
| "struct Bar(x: UInt:8):\n" |
| " x [+1] UInt y\n") |
| self.assertEqual([], dependency_checker.set_dependency_order(ir)) |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([1, 0], struct.fields_in_dependency_order[:2]) |
| |
| def test_dependency_ordering_with_local_parameter(self): |
| ir = _find_dependencies_for_snippet("struct Foo(x: Int:13):\n" |
| " 0 [+x] Int b\n") |
| self.assertEqual([], dependency_checker.set_dependency_order(ir)) |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([0], struct.fields_in_dependency_order[:1]) |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
