ts2famix 1.0.1

package/test/genericClassInheritsInterface.test.ts

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,94 @@
+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');
+    });
+});

package/test/invocationWithFunction.test.ts

@@ -0,0 +1,42 @@
+import { Importer } from '../src/analyze';
+import { Function } from "../src/lib/famix/src/model/famix/function";
+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("invocationWithFunction", 
+    'function func(): void {}\n\
+\n\
+const x1 = func();\n\
+');
+
+describe('Tests for invocation with function', () => {
+    
+    it("should contain a variable 'x1'", () => {
+        const pList = Array.from(fmxRep._getAllEntitiesWithType("Variable") as Set<Variable>);
+        expect(pList).toBeTruthy();
+        const x1 = pList.find(p => p.getName() === "x1");
+        expect(x1).toBeTruthy();
+    });
+    
+    const theFunction = fmxRep._getFamixFunction("func") as Function;
+    const invocations = Array.from(fmxRep._getAllEntitiesWithType("Invocation"));
+    
+    it("should contain one invocation", () => {
+        expect(invocations).toBeTruthy();
+        expect(invocations.length).toBe(1);
+    });
+
+    it("should contain an invocation for 'func'", () => {
+        expect((invocations[0] as Invocation).getCandidates().has(theFunction));
+    });
+
+    it("should contain an invocation with a sender 'invocationWithFunction.ts'", () => {
+        expect((invocations[0] as Invocation).getSender()).toBe(fmxRep._getFamixFile("invocationWithFunction.ts"));
+    });
+
+    it("should contain an invocation with a receiver 'invocationWithFunction.ts'", () => {
+        expect((invocations[0] as Invocation).getReceiver()).toBe(fmxRep._getFamixFile("invocationWithFunction.ts"));
+    });
+});

package/test/invocationWithVariable.test.ts

@@ -0,0 +1,46 @@
+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("invocationWithVariable", 
+    'class AAA {\n\
+    public method(): void {}\n\
+}\n\
+\n\
+const x1 = new AAA();\n\
+x1.method();\n\
+');
+
+describe('Tests for invocation with variable', () => {
+    
+    it("should contain a variable 'x1' instance of 'AAA'", () => {
+        const pList = Array.from(fmxRep._getAllEntitiesWithType("Variable") as Set<Variable>);
+        expect(pList).toBeTruthy();
+        const x1 = pList.find(p => p.getName() === "x1");
+        expect(x1).toBeTruthy();
+        expect(x1?.getDeclaredType().getName()).toBe("AAA");
+    });
+    
+    const theMethod = fmxRep._getFamixMethod("method") as Method;
+    const invocations = Array.from(fmxRep._getAllEntitiesWithType("Invocation"));
+    
+    it("should contain one invocation", () => {
+        expect(invocations).toBeTruthy();
+        expect(invocations.length).toBe(1);
+    });
+
+    it("should contain an invocation for 'method'", () => {
+        expect((invocations[0] as Invocation).getCandidates().has(theMethod));
+    });
+
+    it("should contain an invocation with a sender 'invocationWithVariable.ts'", () => {
+        expect((invocations[0] as Invocation).getSender()).toBe(fmxRep._getFamixFile("invocationWithVariable.ts"));
+    });
+
+    it("should contain an invocation with a receiver 'AAA'", () => {
+        expect((invocations[0] as Invocation).getReceiver()).toBe(fmxRep._getFamixClass("AAA"));
+    });
+});