def test_make_from_type_method_should_succeed(self): tree = self.parse(''' package x; interface Interface {} class Implementation implements Interface {} class AnotherImplementation implements Interface {} class Parameter {} class Client { Interface field = new Implementation(); void f(Parameter p) { Interface local = new AnotherImplementation(); } } ''') set_full_classifiers_names(tree) classifiers, errors = make_classifiers(tree) assert_that(errors, empty()) errors = set_full_types_names(tree, classifiers) assert_that(errors, empty()) types, errors = fill_classifiers(tree, classifiers) assert_that(errors, empty()) make_dependencies(tree, types) assert_that( classifiers['x.Client'].suppliers, equal_to([ classifiers['x.Implementation'], classifiers['x.Parameter'], classifiers['x.Interface'], classifiers['x.AnotherImplementation'], ]))
def test_declaration_of_two_same_classes_should_return_error(self): tree = self.parse(''' class Class {} class Class {} ''') classifiers, errors = make_classifiers(tree) assert_that(classifiers, equal_to({'Class': Class('Class')})) assert_that( errors, equal_to([ClassifierRedeclaration(ClassDeclaration('Class', []))]))
def test_make_class_extends_class_should_succeed(self): tree = self.parse(''' class General {} class Derived extends General {} ''') classifiers, errors = make_classifiers(tree) assert_that(errors, empty()) make_generalizations(tree, classifiers) assert_that(classifiers['Derived'].generals, equal_to([ Class('General'), ]))
def test_declaration_of_two_same_interfaces_should_return_error(self): tree = self.parse(''' interface Interface {} interface Interface {} ''') classifiers, errors = make_classifiers(tree) assert_that(classifiers, equal_to({'Interface': Interface('Interface')})) assert_that( errors, equal_to([ ClassifierRedeclaration(InterfaceDeclaration('Interface', [])) ]))
def test_fill_recursive_class_should_succeed(self): tree = self.parse(''' class A { public A a; } ''') classifiers, errors = make_classifiers(tree) assert_that(errors, empty()) _, errors = fill_classifiers(tree, classifiers) assert_that(errors, empty()) a_type = Type(Class('A')) a_type.classifier.properties = [ Property('a', a_type, Visibility.PUBLIC, is_static=False), ] assert_that(classifiers, equal_to({'A': a_type.classifier}))
def test_make_interface_extends_two_interfaces_should_succeed(self): tree = self.parse(''' interface InterfaceA {} interface InterfaceB {} interface InterfaceC extends InterfaceA, InterfaceB {} ''') classifiers, errors = make_classifiers(tree) assert_that(errors, empty()) make_generalizations(tree, classifiers) assert_that( classifiers['InterfaceC'].generals, equal_to([ Interface('InterfaceA'), Interface('InterfaceB'), ]))
def test_fill_two_same_sub_classes_should_return_error(self): tree = self.parse(''' class Class { class SubClass {} class SubClass {} } ''') classifiers, errors = make_classifiers(tree) assert_that(errors, equal_to( [ClassifierRedeclaration(ClassDeclaration('SubClass', []))])) _, errors = fill_classifiers(tree, classifiers) assert_that(classifiers, equal_to({ 'Class': Class('Class'), 'SubClass': Class('SubClass'), })) assert_that(errors, empty())
def test_fill_one_class_with_one_property_should_succeed(self): tree = self.parse(''' class A { public int a; } ''') classifiers, errors = make_classifiers(tree) assert_that(errors, empty()) _, errors = fill_classifiers(tree, classifiers) assert_that(errors, empty()) assert_that(classifiers, equal_to({ 'A': Class('A', properties=[ Property('a', INT_TYPE, Visibility.PUBLIC, is_static=False) ]), 'int': INT_TYPE.classifier, }))
def test_make_several_class_should_succeed(self): tree = self.parse(''' class C1 {} class C2 {} interface I1 {} interface I2 {} ''') classifiers, errors = make_classifiers(tree) assert_that( classifiers, equal_to({ 'C1': Class('C1'), 'C2': Class('C2'), 'I1': Interface('I1'), 'I2': Interface('I2'), })) assert_that(errors, empty())
def test_make_class_extends_and_implements_should_succeed(self): tree = self.parse(''' interface InterfaceA {} interface InterfaceB {} class General {} class Realization extends General implements InterfaceA, InterfaceB {} ''') classifiers, errors = make_classifiers(tree) assert_that(errors, empty()) make_generalizations(tree, classifiers) assert_that( classifiers['Realization'].generals, equal_to([ Class('General'), Interface('InterfaceA'), Interface('InterfaceB'), ]))
def test_fill_one_class_with_one_operation_should_succeed(self): tree = self.parse(''' class A { void f(int x); } ''') classifiers, errors = make_classifiers(tree) assert_that(errors, empty()) _, errors = fill_classifiers(tree, classifiers) assert_that(errors, empty()) assert_that(classifiers, equal_to({ 'A': Class('A', operations=[ Operation('f', VOID_TYPE, Visibility.PRIVATE, [Parameter('x', INT_TYPE, Direction.IN)], is_static=False), ]), 'void': VOID_TYPE.classifier, 'int': INT_TYPE.classifier, }))
def test_fill_one_class_with_two_same_property_should_return_error(self): tree = self.parse(''' class A { public int a; public float a; } ''') classifiers, errors = make_classifiers(tree) assert_that(errors, empty()) _, errors = fill_classifiers(tree, classifiers) assert_that(len(errors), equal_to(1)) assert_that(str(errors[0]), equal_to( 'error: redeclaration of variable "a" in class "A"')) assert_that(classifiers, equal_to({ 'A': Class('A', properties=[ Property('a', INT_TYPE, Visibility.PUBLIC, is_static=False), ]), 'int': INT_TYPE.classifier, }))
def test_fill_enum_with_overriding_in_item_should_succeed(self): tree = self.parse(''' enum Enum { Item { @Override public void f() {} }; public abstract void f(); } ''') classifiers, errors = make_classifiers(tree) _, errors = fill_classifiers(tree, classifiers) assert_that(classifiers, equal_to({ 'Enum': Class('Enum', operations=[ Operation('f', VOID_TYPE, Visibility.PUBLIC, is_static=False), ]), 'void': VOID_TYPE.classifier, })) assert_that(errors, empty())
def test_fill_class_with_overriding_method_in_object_should_succeed(self): tree = self.parse(''' class A { void g(); void f() { new A() { public void h(); }; } } ''') classifiers, errors = make_classifiers(tree) assert_that(errors, empty()) _, errors = fill_classifiers(tree, classifiers) assert_that(errors, empty()) assert_that(classifiers, equal_to({ 'A': Class('A', operations=[ Operation('f', VOID_TYPE, Visibility.PRIVATE, is_static=False), Operation('g', VOID_TYPE, Visibility.PRIVATE, is_static=False), ]), 'void': VOID_TYPE.classifier, }))
def test_fill_class_with_field_instance_creation_item_should_succeed(self): tree = self.parse(''' class Class { Class value = new Class() { @Override public void f() {}; }; public abstract void f(); } ''') classifiers, errors = make_classifiers(tree) _, errors = fill_classifiers(tree, classifiers) class_type = Type(Class('Class', operations=[ Operation('f', VOID_TYPE, Visibility.PUBLIC, is_static=False), ])) class_type.classifier.properties = [ Property('value', class_type, Visibility.PRIVATE, is_static=False)] assert_that(classifiers, equal_to({ 'Class': class_type.classifier, 'void': VOID_TYPE.classifier, })) assert_that(errors, empty())
def test_fill_one_class_with_local_class_should_succeed(self): tree = self.parse(''' class A { void f() { class B extends A { void g(); } } } ''') classifiers, errors = make_classifiers(tree) assert_that(errors, empty()) _, errors = fill_classifiers(tree, classifiers) assert_that(errors, empty()) assert_that(classifiers, equal_to({ 'A': Class('A', operations=[ Operation('f', VOID_TYPE, Visibility.PRIVATE, is_static=False), ]), 'B': Class('B', operations=[ Operation('g', VOID_TYPE, Visibility.PRIVATE, is_static=False), ]), 'void': VOID_TYPE.classifier, }))
def test_fill_one_class_with_two_same_operations_should_return_error(self): tree = self.parse(''' class A { void f(int x); void f(int x); } ''') classifiers, errors = make_classifiers(tree) assert_that(errors, empty()) _, errors = fill_classifiers(tree, classifiers) assert_that(len(errors), equal_to(1)) assert_that(str(errors[0]), equal_to( 'error: redeclaration of method "-A::f(in x: int): void" in class ' '"A"') ) assert_that(classifiers, equal_to({ 'A': Class('A', operations=[ Operation('f', VOID_TYPE, Visibility.PRIVATE, [Parameter('x', INT_TYPE, Direction.IN)], is_static=False), ]), 'void': VOID_TYPE.classifier, 'int': INT_TYPE.classifier, }))
def test_make_from_empty_should_succeed(self): tree = self.parse('') classifiers, errors = make_classifiers(tree) assert_that(errors, empty()) make_generalizations(tree, classifiers)
def test_make_one_interface_should_succeed(self): tree = self.parse('interface I {}') classifiers, errors = make_classifiers(tree) assert_that(classifiers, equal_to({'I': Interface('I')})) assert_that(errors, empty())
def test_make_one_class_should_succeed(self): tree = self.parse('class C {}') classifiers, errors = make_classifiers(tree) assert_that(classifiers, equal_to({'C': Class('C')})) assert_that(errors, empty())
def test_make_from_empty_should_succeed(self): tree = self.parse('') classifiers, errors = make_classifiers(tree) assert_that(classifiers, equal_to({})) assert_that(errors, empty())