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