def test_declared_function_is_accessible(self): scope = Scope() scope.declare_func(AccessLevel.internal, "foo", {"x": Int}, Int) self.assertDictEqual( scope.accessible_functions(), { "foo": FunctionType(AccessLevel.internal, {"x": Int}, Int), } )
def test_deeply_nested_type_is_accessible(self): A = EnumType("A") scope = Scope() scope.add_child(Scope()) scope.children[0].add_child(Scope()) scope.children[0].children[0].add_child(Scope()) scope.children[0].children[0].children[0].add_child(Scope(datatype=A)) self.assertSetEqual(set(scope.accessible_types()), {A})
def test_importing_standard_library_exposes_expected_values(self): scope = Scope() scope.import_standard_library() self.assertSetEqual(set(scope.accessible_types()), {Bool, Int, Optional}) self.assertSetEqual( set(scope.accessible_functions().keys()), {"&+", "&*", ">", "=="}, ) self.assertSetEqual(set(scope.accessible_variables()), set())
def test_specialize_generic_type(self): scope = Scope() GT = DataType("GT") A = DataType("A", access=AccessLevel.internal) scope.add_child(Scope(None, A)) B = DataType("B", generic_types={GT: None}) self.assertDictEqual(scope.specialize_type(B).generic_types, {GT: A})
def test_accessible_functions_hides_private_static_methods(self): root = Scope() A = DataType("A", static_methods={ "a": FunctionType(AccessLevel.private, {}, Int), "b": FunctionType(AccessLevel.fileprivate, {}, Int), }) root.add_child(Scope(datatype=A)) self.assertSetEqual({"A.b"}, set(root.accessible_functions().keys()))
def test_specialize_generic_type_filter(self): scope = Scope() GT = DataType("GT") A = DataType("A", access=AccessLevel.internal) B = DataType("B", access=AccessLevel.public) scope.add_child(Scope(None, A)) scope.add_child(Scope(None, B)) C = DataType("C", generic_types={GT: None}) self.assertDictEqual( scope.specialize_type(C, at_least=AccessLevel.public).generic_types, {GT: B} )
def test_accessible_functions_access_level_filter(self): scope = Scope() scope.declare_func(AccessLevel.public, "foo", {}, Int) scope.declare_func(AccessLevel.internal, "bar", {}, Int) scope.declare_func(AccessLevel.private, "baz", {}, Int) self.assertSetEqual( set(scope.accessible_functions(at_least=AccessLevel.public).keys()), {"foo"} ) self.assertSetEqual( set(scope.accessible_functions(at_least=AccessLevel.internal).keys()), {"foo", "bar"} ) self.assertSetEqual( set(scope.accessible_functions(at_least=AccessLevel.private).keys()), {"foo", "bar", "baz"} )
def test_accessible_types_include_self_filter(self): A = EnumType("A") root = Scope(datatype=A) self.assertSetEqual(set(root.accessible_types()), set()) self.assertSetEqual(set(root.accessible_types(include_self=False)), set()) self.assertSetEqual(set(root.accessible_types(include_self=True)), {A})
def test_declared_variable_is_accessible(self): scope = Scope() scope.declare("foo", Int, False) self.assertSetEqual(set(scope.accessible_variables()), {("foo", Int, False)})
def test_accessible_types_access_level_filter(self): A = EnumType("A", access=AccessLevel.public) B = EnumType("B", access=AccessLevel.internal) C = EnumType("C", access=AccessLevel.fileprivate) root = Scope() root.add_child(Scope(None, A)) root.add_child(Scope(None, B)) root.add_child(Scope(None, C)) self.assertSetEqual( set(root.accessible_types(at_least=AccessLevel.fileprivate)), {A, B, C} ) self.assertSetEqual( set(root.accessible_types(at_least=AccessLevel.internal)), {A, B} ) self.assertSetEqual( set(root.accessible_types(at_least=AccessLevel.public)), {A} )
def test_enclosing_sibling_type_is_accessible(self): A = EnumType("A") grandparent = Scope() parent = Scope() grandparent.add_child(parent) uncle = Scope(datatype=A) grandparent.add_child(uncle) child = Scope() parent.add_child(child) self.assertSetEqual(set(child.accessible_types()), {A})