ts2famix 1.0.1 → 1.0.4

package/test/functionsInFunction.test.ts

@@ -1,40 +0,0 @@
-import { Importer } from '../src/analyze';
-import { Function } from "../src/lib/famix/src/model/famix/function";
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("functionsInFunction", 
-    'function fct() {\n\
-    function fct2() {\n\
-        function fct3() {\n\
-            return 0;\n\
-        }\n\
-    }\n\
-}\n\
-');
-
-describe('Tests for functions in function', () => {
-    
-    const theFunction1 = fmxRep._getFamixFunction("fct");
-    const theFunction2 = fmxRep._getFamixFunction("fct2");
-    const theFunction3 = fmxRep._getFamixFunction("fct3");
-
-    it("should have one function 'fct' with a function 'fct2'", () => {
-        expect(theFunction1).toBeTruthy();
-        expect(theFunction2).toBeTruthy();
-        expect(theFunction1?.getFunctions().size).toBe(1);
-        expect(Array.from(theFunction1?.getFunctions() as Set<Function>)[0]).toBe(theFunction2);
-    });
-
-    it("should have one function 'fct2' with a function 'fct3'", () => {
-        expect(theFunction2).toBeTruthy();
-        expect(theFunction3).toBeTruthy();
-        expect(theFunction2?.getFunctions().size).toBe(1);
-        expect(Array.from(theFunction2?.getFunctions() as Set<Function>)[0]).toBe(theFunction3);
-    });
-
-    it("should have one function 'fct3' with no function", () => {
-        expect(theFunction3).toBeTruthy();
-        expect(theFunction3?.getFunctions().size).toBe(0);
-    });
-});

package/test/functionsInMethod.test.ts

@@ -1,42 +0,0 @@
-import { Importer } from '../src/analyze';
-import { Function } from "../src/lib/famix/src/model/famix/function";
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("functionsInMethod", 
-    'class F {\n\
-    m() {\n\
-        function fct2() {\n\
-            function fct3() {\n\
-                return 0;\n\
-            }\n\
-        }\n\
-    }\n\
-}\n\
-');
-
-describe('Tests for functions in method', () => {
-    
-    const theMethod = fmxRep._getFamixMethod("m");
-    const theFunction2 = fmxRep._getFamixFunction("fct2");
-    const theFunction3 = fmxRep._getFamixFunction("fct3");
-
-    it("should have one method 'm' with a function 'fct2'", () => {
-        expect(theMethod).toBeTruthy();
-        expect(theFunction2).toBeTruthy();
-        expect(theMethod?.getFunctions().size).toBe(1);
-        expect(Array.from(theMethod?.getFunctions() as Set<Function>)[0]).toBe(theFunction2);
-    });
-
-    it("should have one function 'fct2' with a function 'fct3'", () => {
-        expect(theFunction2).toBeTruthy();
-        expect(theFunction3).toBeTruthy();
-        expect(theFunction2?.getFunctions().size).toBe(1);
-        expect(Array.from(theFunction2?.getFunctions() as Set<Function>)[0]).toBe(theFunction3);
-    });
-
-    it("should have one function 'fct3' with no function", () => {
-        expect(theFunction3).toBeTruthy();
-        expect(theFunction3?.getFunctions().size).toBe(0);
-    });
-});

package/test/genericClass.test.ts

@@ -1,42 +0,0 @@
-import { Importer } from '../src/analyze';
-import { ParameterizableClass, TypeParameter } from '../src/lib/famix/src/model/famix';
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("genericClass", 
-    'class MyClass<T> {}\n\
-');
-
-describe('Tests for generic class', () => {
-
-    it("should parse generics", () => {
-        expect(fmxRep).toBeTruthy();
-    });
-
-    it("should contain one generic class", () => {
-        expect(fmxRep._getAllEntitiesWithType("ParameterizableClass").size).toBe(1);
-    });
-
-    it("should contain a generic class MyClass", () => {
-        const listOfNames = Array.from(fmxRep._getAllEntitiesWithType("ParameterizableClass")).map(e => (e as ParameterizableClass).getName());
-        expect(listOfNames).toContain("MyClass");
-    });
-
-    it("should contain a generic class MyClass with a type parameter T", () => {
-        const pList = Array.from(fmxRep._getAllEntitiesWithType("ParameterizableClass") as Set<ParameterizableClass>);
-        expect(pList).toBeTruthy();
-        const MyClass = pList.find(p => p.getName() === "MyClass");
-        expect(MyClass).toBeTruthy();
-        expect(MyClass?.getTypeParameters().size).toBe(1);
-        if (MyClass) {
-            expect((Array.from(MyClass.getTypeParameters())[0] as TypeParameter).getName()).toBe("T");
-            expect((Array.from(MyClass.getTypeParameters())[0] as TypeParameter).getParentGeneric()).toBe(MyClass);
-        }
-    });
-
-    const theClass = fmxRep._getFamixClass("MyClass");
-    it ("should not be an abstract class", () => {
-        expect(theClass).toBeTruthy();
-        if (theClass) expect(theClass.getIsAbstract()).toBe(false);
-    });
-});

package/test/genericClassInheritsInterface.test.ts

@@ -1,47 +0,0 @@
-import { Importer } from '../src/analyze';
-import { ParameterizableClass, ParameterizableInterface } from '../src/lib/famix/src/model/famix';
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("genericClassInheritsInterface", 
-    'interface MyDaoInterface<T> {}\n\
-\n\
-class MyDao<T> implements MyDaoInterface<T> {}\n\
-');
-
-describe('Tests for generic class inherits interface', () => {
-
-    it("should parse generics", () => {
-        expect(fmxRep).toBeTruthy();
-    });
-
-    it("should contain one generic class and one generic interface", () => {
-        expect(fmxRep._getAllEntitiesWithType("ParameterizableClass").size).toBe(1);
-        expect(fmxRep._getAllEntitiesWithType("ParameterizableInterface").size).toBe(1);
-    });
-
-    it("should contain a generic class MyDao that implements a generic interface MyDaoInterface", () => {
-        const cList = Array.from(fmxRep._getAllEntitiesWithType("ParameterizableClass") as Set<ParameterizableClass>);
-        expect(cList).toBeTruthy();
-        const myDao = cList.find(p => p.getName() === "MyDao");
-        expect(myDao).toBeTruthy();
-        const iList = Array.from(fmxRep._getAllEntitiesWithType("ParameterizableInterface") as Set<ParameterizableInterface>);
-        expect(iList).toBeTruthy();
-        const myDaoInterface = iList.find(p => p.getName() === "MyDaoInterface");
-        expect(myDaoInterface).toBeTruthy();
-        if (myDao) {
-            expect(myDao.getSubInheritances().size).toBe(0);
-            expect(myDao.getSuperInheritances().size).toBe(1);
-            const theInheritance = (Array.from(myDao.getSuperInheritances())[0]);
-            expect(theInheritance.getSuperclass()).toBeTruthy();
-            expect(theInheritance.getSuperclass()).toBe(myDaoInterface);
-        }
-        if (myDaoInterface) {
-            expect(myDaoInterface.getSubInheritances().size).toBe(1);
-            expect(myDaoInterface.getSuperInheritances().size).toBe(0);
-            const theInheritance = (Array.from(myDaoInterface.getSubInheritances())[0]);
-            expect(theInheritance.getSubclass()).toBeTruthy();
-            expect(theInheritance.getSubclass()).toBe(myDao);
-        }
-    });
-});

package/test/genericInterface.test.ts

@@ -1,38 +0,0 @@
-import { Importer } from '../src/analyze';
-import { ParameterizableInterface, TypeParameter } from '../src/lib/famix/src/model/famix';
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("genericInterface", 
-    'interface MyInterface<T> {\n\
-    myProperty;\n\
-    myMethod();\n\
-}\n\
-');
-
-describe('Tests for generic interface', () => {
-
-    it("should parse generics", () => {
-        expect(fmxRep).toBeTruthy();
-    });
-
-    it("should contain one generic interface", () => {
-        expect(fmxRep._getAllEntitiesWithType("ParameterizableInterface").size).toBe(1);
-    });
-
-    it("should contain a generic interface MyInterface", () => {
-        const listOfNames = Array.from(fmxRep._getAllEntitiesWithType("ParameterizableInterface")).map(e => (e as ParameterizableInterface).getName());
-        expect(listOfNames).toContain("MyInterface");
-    });
-
-    it("should contain a generic interface MyInterface with a type parameter T", () => {
-        const pList = Array.from(fmxRep._getAllEntitiesWithType("ParameterizableInterface") as Set<ParameterizableInterface>);
-        expect(pList).toBeTruthy();
-        const MyInterface = pList.find(p => p.getName() === "MyInterface");
-        expect(MyInterface).toBeTruthy();
-        expect(MyInterface?.getTypeParameters().size).toBe(1);
-        if (MyInterface) {
-            expect((Array.from(MyInterface.getTypeParameters())[0] as TypeParameter).getName()).toBe("T");
-        }
-    });
-});

package/test/genericMethod.test.ts

@@ -1,65 +0,0 @@
-import { Importer } from '../src/analyze';
-import { Class } from "../src/lib/famix/src/model/famix/class";
-import { Method } from "../src/lib/famix/src/model/famix/method";
-import { Parameter } from "../src/lib/famix/src/model/famix/parameter";
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("genericMethod", 
-    'class AA {\n\
-    public i<T> (j: T): void {}\n\
-}\n\
-');
-
-describe('Tests for generics', () => {
-
-    const theClass = fmxRep._getFamixClass("AA");
-
-    it("should parse generics", () => {
-        expect(fmxRep).toBeTruthy();
-    });
-    
-    it("should contain one class", () => {
-        expect(fmxRep._getAllEntitiesWithType("Class").size).toBe(1);
-    });
-
-    it("should contain a class AA", () => {
-        const listOfNames = Array.from(fmxRep._getAllEntitiesWithType("Class")).map(e => (e as Class).getName());
-        expect(listOfNames).toContain("AA");
-    });
-
-    it("should not be an abstract class", () => {
-        expect(theClass).toBeTruthy();
-        if (theClass) expect(theClass.getIsAbstract()).toBe(false);
-    });
-
-    it("should contain a generic method i for class AA with type parameter T", () => {
-        const cList = Array.from(fmxRep._getAllEntitiesWithType("Class") as Set<Class>);
-        expect(cList).toBeTruthy();
-        const AA = cList.find(c => c.getName() === "AA");
-        const mList = Array.from(AA?.getMethods() as Set<Method>);
-        const i = mList?.find(m => m.getName() === "i");
-        expect(i).toBeTruthy();
-        expect(i?.getDeclaredType().getName()).toBe("void");
-        expect(i?.getParameters().size).toBe(1);
-        const pList = Array.from(i?.getParameters() as Set<Parameter>);
-        const j = pList?.find(p => p.getName() === "j");
-        expect(j).toBeTruthy();
-        expect(j?.getDeclaredType().getName()).toBe("T");
-    });
-
-    it("should contain a public method i", () => {
-        const pList = Array.from(fmxRep._getAllEntitiesWithType("Method") as Set<Method>);
-        expect(pList).toBeTruthy();
-        const i = pList.find(p => p.getName() === "i");
-        expect(i).toBeTruthy();
-        if (i) {
-            expect(i.getKind()).toBe(undefined);
-            expect(i.getIsAbstract()).toBe(false);
-            expect(i.getIsClassSide()).toBe(false);
-            expect(i.getIsPrivate()).toBe(false);
-            expect(i.getIsProtected()).toBe(false);
-            expect(i.getIsPublic()).toBe(true);
-        }
-    });
-});

package/test/genericWithInvocation.test.ts

@@ -1,71 +0,0 @@
-import { Importer } from '../src/analyze';
-import { Method } from "../src/lib/famix/src/model/famix/method";
-import { Variable } from "../src/lib/famix/src/model/famix/variable";
-import { Invocation } from "../src/lib/famix/src/model/famix/invocation";
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("genericWithInvocation", 
-    'class AA {\n\
-    public i<T> (j: T): void {}\n\
-}\n\
-\n\
-const x = new AA();\n\
-x.i<string>("ok");\n\
-');
-
-describe('Tests for generics', () => {
-
-    const theMethod = fmxRep._getFamixMethod("i") as Method;
-
-    it("should parse generics", () => {
-        expect(fmxRep).toBeTruthy();
-    });
-
-    it("should contain a variable x instance of AA", () => {
-        const pList = Array.from(fmxRep._getAllEntitiesWithType("Variable") as Set<Variable>);
-        expect(pList).toBeTruthy();
-        const x = pList.find(p => p.getName() === "x");
-        expect(x).toBeTruthy();
-        expect(x?.getDeclaredType().getName()).toBe("AA");
-    });
-    
-    it("should contain an invocation for i", () => {
-        expect(theMethod).toBeTruthy();
-        const invocations = Array.from(fmxRep._getAllEntitiesWithType("Invocation"));
-        expect(invocations).toBeTruthy();
-        expect(invocations.length).toBe(1);
-        const candidates = invocations.filter(i => {
-            const invocation = i as Invocation;
-            return invocation.getCandidates().has(theMethod);
-        });
-        expect(candidates).toHaveLength(1);
-    });
-
-    it("should contain an invocation for i with a sender 'genericWithInvocation.ts'", () => {
-        expect(theMethod).toBeTruthy();
-        const invocations = Array.from(fmxRep._getAllEntitiesWithType("Invocation"));
-        expect(invocations).toBeTruthy();
-        expect(invocations.length).toBe(1);
-        expect((invocations[0] as Invocation).getSender()).toBeTruthy();
-        expect((invocations[0] as Invocation).getSender()).toBe(fmxRep._getFamixFile("genericWithInvocation.ts"));
-    });
-
-    it("should contain an invocation for i with a receiver 'AA'", () => {
-        expect(theMethod).toBeTruthy();
-        const invocations = Array.from(fmxRep._getAllEntitiesWithType("Invocation"));
-        expect(invocations).toBeTruthy();
-        expect(invocations.length).toBe(1);
-        expect((invocations[0] as Invocation).getReceiver()).toBeTruthy();
-        expect((invocations[0] as Invocation).getReceiver()).toBe(fmxRep._getFamixClass("AA"));
-    });
-
-    it("should contain an invocation for i with a signature 'public i<T> (j: T): void'", () => {
-        expect(theMethod).toBeTruthy();
-        const invocations = Array.from(fmxRep._getAllEntitiesWithType("Invocation"));
-        expect(invocations).toBeTruthy();
-        expect(invocations.length).toBe(1);
-        expect((invocations[0] as Invocation).getSignature()).toBeTruthy();
-        expect((invocations[0] as Invocation).getSignature()).toBe('public i<T> (j: T): void');
-    });
-});

package/test/generics.test.ts

@@ -1,68 +0,0 @@
-import { Importer } from '../src/analyze';
-import { ParameterizableClass, ParameterizableInterface, TypeParameter } from '../src/lib/famix/src/model/famix';
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("generics", 
-    'interface MyDaoInterface<T> {}\n\
-\n\
-class MyDao<T> implements MyDaoInterface<T> {}\n\
-');
-
-describe('Generics', () => {
-
-    it("should parse generics", () => {
-        expect(fmxRep).toBeTruthy();
-    });
-    
-    it("should contain one generic class and one generic interface", () => {
-        expect(fmxRep._getAllEntitiesWithType("ParameterizableClass").size).toBe(1);
-        expect(fmxRep._getAllEntitiesWithType("ParameterizableInterface").size).toBe(1);
-    });
-    
-    it("should contain a generic class MyDao and a generic interface MyDaoInterface", () => {
-        const listOfNames = Array.from(fmxRep._getAllEntitiesWithType("ParameterizableClass")).map(e => (e as ParameterizableClass).getName());
-        expect(listOfNames).toContain("MyDao");
-        const listOfNames2 = Array.from(fmxRep._getAllEntitiesWithType("ParameterizableInterface")).map(e => (e as ParameterizableInterface).getName());
-        expect(listOfNames2).toContain("MyDaoInterface");
-    });
-    
-    it("should contain a generic class MyDao with a type parameter T", () => {
-        const pList = Array.from(fmxRep._getAllEntitiesWithType("ParameterizableClass") as Set<ParameterizableClass>);
-        expect(pList).toBeTruthy();
-        const myDao = pList.find(p => p.getName() === "MyDao");
-        expect(myDao).toBeTruthy();
-        expect(myDao?.getTypeParameters().size).toBe(1);
-        if (myDao) {
-            expect((Array.from(myDao.getTypeParameters())[0] as TypeParameter).getName()).toBe("T");
-        }
-    });
-    
-    it("should contain a generic interface MyDaoInterface with a type parameter T", () => {
-        const pList = Array.from(fmxRep._getAllEntitiesWithType("ParameterizableInterface") as Set<ParameterizableInterface>);
-        expect(pList).toBeTruthy();
-        const myDaoInterface = pList.find(p => p.getName() === "MyDaoInterface");
-        expect(myDaoInterface).toBeTruthy();
-        expect(myDaoInterface?.getTypeParameters().size).toBe(1);
-        if (myDaoInterface) {
-            expect((Array.from(myDaoInterface.getTypeParameters())[0] as TypeParameter).getName()).toBe("T");
-        }
-    });
-    
-    it("should contain a generic class MyDao that implements a generic interface MyDaoInterface", () => {
-        const cList = Array.from(fmxRep._getAllEntitiesWithType("ParameterizableClass") as Set<ParameterizableClass>);
-        expect(cList).toBeTruthy();
-        const myDao = cList.find(p => p.getName() === "MyDao");
-        expect(myDao).toBeTruthy();
-        const iList = Array.from(fmxRep._getAllEntitiesWithType("ParameterizableInterface") as Set<ParameterizableInterface>);
-        expect(iList).toBeTruthy();
-        const myDaoInterface = iList.find(p => p.getName() === "MyDaoInterface");
-        expect(myDaoInterface).toBeTruthy();
-        if (myDao) {
-            expect(myDao.getSuperInheritances().size).toBe(1);
-            const theInheritance = (Array.from(myDao.getSuperInheritances())[0]);
-            expect(theInheritance.getSuperclass()).toBeTruthy();
-            expect(theInheritance.getSuperclass()).toBe(myDaoInterface);
-        }
-    });
-});

package/test/inheritance.test.ts

@@ -1,50 +0,0 @@
-import { Importer } from '../src/analyze';
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("inheritance", 
-    'class Animal {}\n\
-class Fish extends Animal {}\n\
-interface Flyable {}\n\
-class Bird extends Animal implements Flyable {}\n\
-');
-
-describe('Inheritance', () => {
-
-    const jsonOutput = fmxRep.getJSON();
-    const parsedModel = JSON.parse(jsonOutput);
-    const idToElementMap = fmxRep._initMapFromModel(jsonOutput);    
-
-    it("should contain a Fish class who has a superclass Animal", () => {
-        const fishCls = parsedModel.filter(el => (el.FM3 === "FamixTypeScript.Class" && el.name === "Fish"))[0];
-        const superInheritance = idToElementMap.get(fishCls.superInheritances[0].ref) as any;
-        expect((idToElementMap.get(superInheritance.superclass.ref) as any).name).toBe("Animal");
-    });
-
-    it("should contain an Animal class who has a subclass Fish", () => {
-        const animalCls = parsedModel.filter(el => (el.FM3 === "FamixTypeScript.Class" && el.name === "Animal"))[0];
-        const subInheritance = idToElementMap.get(animalCls.subInheritances[0].ref) as any;
-        expect((idToElementMap.get(subInheritance.subclass.ref) as any).name).toBe("Fish");
-    });
-    
-    it("should contain a Flyable interface", () => {
-        const flyableInterface = parsedModel.filter(el => (el.FM3 === "FamixTypeScript.Interface" && el.name === "Flyable"))[0];
-        expect(flyableInterface).toBeTruthy();
-    });
-    
-    it("should contain a Bird class who has a superclass Animal and implements a Flyable interface", () => {
-        const animalCls = parsedModel.filter(el => (el.FM3 === "FamixTypeScript.Class" && el.name === "Animal"))[0];
-        expect(animalCls).toBeTruthy();
-        const flyableInterface = parsedModel.filter(el => (el.FM3 === "FamixTypeScript.Interface" && el.name === "Flyable"))[0];
-        expect(flyableInterface).toBeTruthy();
-        const birdCls = parsedModel.filter(el => (el.FM3 === "FamixTypeScript.Class" && el.name === "Bird"))[0];
-        expect(birdCls).toBeTruthy();
-        // extends Animal, implements Flyable
-        const birdSuperInheritances = birdCls.superInheritances;
-        expect(birdSuperInheritances.length).toBe(2);
-        const extendsRef = birdSuperInheritances.filter(si => (si.ref === animalCls.ref));
-        expect(extendsRef).toBeTruthy();
-        const interfaceRef = birdSuperInheritances.filter(si => (si.ref === flyableInterface.ref));
-        expect(interfaceRef).toBeTruthy();
-    });
-});

package/test/interfaceInheritsInterface.test.ts

@@ -1,40 +0,0 @@
-import { Importer } from '../src/analyze';
-import { Interface } from '../src/lib/famix/src/model/famix';
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("interfaceInheritsInterface", 
-    'interface MyInterface1 {}\n\
-\n\
-interface MyInterface2 extends MyInterface1 {}\n\
-');
-
-describe('Tests for interface inherits interface', () => {
-
-    it("should contain two interfaces", () => {
-        expect(fmxRep._getAllEntitiesWithType("Interface").size).toBe(2);
-    });
-
-    it("should contain an interface MyInterface2 that extends an interface MyInterface1", () => {
-        const cList = Array.from(fmxRep._getAllEntitiesWithType("Interface") as Set<Interface>);
-        expect(cList).toBeTruthy();
-        const myInterface1 = cList.find(p => p.getName() === "MyInterface1");
-        expect(myInterface1).toBeTruthy();
-        const myInterface2 = cList.find(p => p.getName() === "MyInterface2");
-        expect(myInterface2).toBeTruthy();
-        if (myInterface2) {
-            expect(myInterface2.getSubInheritances().size).toBe(0);
-            expect(myInterface2.getSuperInheritances().size).toBe(1);
-            const theInheritance = (Array.from(myInterface2.getSuperInheritances())[0]);
-            expect(theInheritance.getSuperclass()).toBeTruthy();
-            expect(theInheritance.getSuperclass()).toBe(myInterface1);
-        }
-        if (myInterface1) {
-            expect(myInterface1.getSubInheritances().size).toBe(1);
-            expect(myInterface1.getSuperInheritances().size).toBe(0);
-            const theInheritance = (Array.from(myInterface1.getSubInheritances())[0]);
-            expect(theInheritance.getSubclass()).toBeTruthy();
-            expect(theInheritance.getSubclass()).toBe(myInterface2);
-        }
-    });
-});

package/test/interfaceInheritsUndefinedInterface.test.ts

@@ -1,41 +0,0 @@
-import { Importer } from '../src/analyze';
-import { Interface } from '../src/lib/famix/src/model/famix';
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("interfaceInheritsUndefinedInterface", 
-    'import {FileSystemHost} from "ts-morph";\n\
-\n\
-interface MyInterface extends FileSystemHost {}\n\
-');
-
-describe('Tests for interface inherits undefined interface', () => {
-
-    it("should contain two interfaces", () => {
-        expect(fmxRep._getAllEntitiesWithType("Interface").size).toBe(2);
-    });
-
-    it("should contain an interface MyInterface that extends an interface FileSystemHost", () => {
-        const cList = Array.from(fmxRep._getAllEntitiesWithType("Interface") as Set<Interface>);
-        expect(cList).toBeTruthy();
-        const myInterface1 = cList.find(p => p.getName() === "FileSystemHost");
-        expect(myInterface1).toBeTruthy();
-        expect(myInterface1?.getIsStub()).toBe(true);
-        const myInterface2 = cList.find(p => p.getName() === "MyInterface");
-        expect(myInterface2).toBeTruthy();
-        if (myInterface2) {
-            expect(myInterface2.getSubInheritances().size).toBe(0);
-            expect(myInterface2.getSuperInheritances().size).toBe(1);
-            const theInheritance = (Array.from(myInterface2.getSuperInheritances())[0]);
-            expect(theInheritance.getSuperclass()).toBeTruthy();
-            expect(theInheritance.getSuperclass()).toBe(myInterface1);
-        }
-        if (myInterface1) {
-            expect(myInterface1.getSubInheritances().size).toBe(1);
-            expect(myInterface1.getSuperInheritances().size).toBe(0);
-            const theInheritance = (Array.from(myInterface1.getSubInheritances())[0]);
-            expect(theInheritance.getSubclass()).toBeTruthy();
-            expect(theInheritance.getSubclass()).toBe(myInterface2);
-        }
-    });
-});

package/test/invocation.test.ts

@@ -1,94 +0,0 @@
-import { Importer } from '../src/analyze';
-import { Class } from "../src/lib/famix/src/model/famix/class";
-import { Method } from "../src/lib/famix/src/model/famix/method";
-import { Invocation } from "../src/lib/famix/src/model/famix/invocation";
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("invocation", 
-    'class A {\n\
-    public x(): void {}\n\
-}\n\
-\n\
-class B {\n\
-    public y(): void {\n\
-        new A().x();\n\
-    }\n\
-}\n\
-');
-
-describe('Tests for invocation', () => {
-
-    const theMethod = fmxRep._getFamixMethod("x") as Method;
-
-    it("should contain two class", () => {
-        expect(fmxRep._getAllEntitiesWithType("Class").size).toBe(2);
-    });
-
-    it("should contain a class A and a class B", () => {
-        const listOfNames = Array.from(fmxRep._getAllEntitiesWithType("Class")).map(e => (e as Class).getName());
-        expect(listOfNames).toContain("A");
-        expect(listOfNames).toContain("B");
-    });
-
-    it("should contain a method x for class A", () => {
-        const cList = Array.from(fmxRep._getAllEntitiesWithType("Class") as Set<Class>);
-        expect(cList).toBeTruthy();
-        const A = cList.find(c => c.getName() === "A");
-        const mList = Array.from(A?.getMethods() as Set<Method>);
-        const x = mList?.find(m => m.getName() === "x");
-        expect(x).toBeTruthy();
-        expect(x?.getDeclaredType().getName()).toBe("void");
-        expect(x?.getParameters().size).toBe(0);
-    });
-
-    it("should contain a method y for class B", () => {
-        const cList = Array.from(fmxRep._getAllEntitiesWithType("Class") as Set<Class>);
-        expect(cList).toBeTruthy();
-        const B = cList.find(c => c.getName() === "B");
-        const mList = Array.from(B?.getMethods() as Set<Method>);
-        const y = mList?.find(m => m.getName() === "y");
-        expect(y).toBeTruthy();
-        expect(y?.getDeclaredType().getName()).toBe("void");
-        expect(y?.getParameters().size).toBe(0);
-    });
-
-    it("should contain an invocation for x", () => {
-        expect(theMethod).toBeTruthy();
-        const invocations = Array.from(fmxRep._getAllEntitiesWithType("Invocation"));
-        expect(invocations).toBeTruthy();
-        expect(invocations.length).toBe(1);
-        const candidates = invocations.filter(i => {
-            const invocation = i as Invocation;
-            return invocation.getCandidates().has(theMethod);
-        });
-        expect(candidates).toHaveLength(1);
-    });
-
-    it("should contain an invocation for x with a sender 'y'", () => {
-        expect(theMethod).toBeTruthy();
-        const invocations = Array.from(fmxRep._getAllEntitiesWithType("Invocation"));
-        expect(invocations).toBeTruthy();
-        expect(invocations.length).toBe(1);
-        expect((invocations[0] as Invocation).getSender()).toBeTruthy();
-        expect((invocations[0] as Invocation).getSender()).toBe(fmxRep._getFamixMethod("y"));
-    });
-
-    it("should contain an invocation for x with a receiver 'A'", () => {
-        expect(theMethod).toBeTruthy();
-        const invocations = Array.from(fmxRep._getAllEntitiesWithType("Invocation"));
-        expect(invocations).toBeTruthy();
-        expect(invocations.length).toBe(1);
-        expect((invocations[0] as Invocation).getReceiver()).toBeTruthy();
-        expect((invocations[0] as Invocation).getReceiver()).toBe(fmxRep._getFamixClass("A"));
-    });
-
-    it("should contain an invocation for x with a signature 'public x(): void'", () => {
-        expect(theMethod).toBeTruthy();
-        const invocations = Array.from(fmxRep._getAllEntitiesWithType("Invocation"));
-        expect(invocations).toBeTruthy();
-        expect(invocations.length).toBe(1);
-        expect((invocations[0] as Invocation).getSignature()).toBeTruthy();
-        expect((invocations[0] as Invocation).getSignature()).toBe('public x(): void');
-    });
-});