| # 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() |
