ts2famix 1.0.1

package/test/entities.test.ts

@@ -0,0 +1,232 @@
+import { Importer } from '../src/analyze';
+import { Method, Function, Variable} from '../src/lib/famix/src/model/famix';
+
+const importer = new Importer();
+
+const fmxRep = importer.famixRepFromSource("entities", 
+    'namespace MyNamespace {\n\
+    \n\
+    class EntityClass {\n\
+        public name: string;\n\
+        private p1: boolean; // type-only private\n\
+        #p2: boolean; // runtime private\n\
+        protected prot1: Map<any, any>;\n\
+        trustMe!: string;\n\
+        readonly ro = "yes";\n\
+        static #userCount: number;\n\
+        optional?: string;\n\
+        \n\
+        constructor() {}\n\
+        public move() {}\n\
+        private move2(family: string): void {}\n\
+        #move3() {}\n\
+    }\n\
+    \n\
+    class class2 extends EntityClass {}\n\
+    \n\
+    class clsInNsp {\n\
+        public static aStaticMethod() {}\n\
+    }\n\
+}\n\
+\n\
+// global scope\n\
+var globalA;\n\
+function globalFunc() {}\n\
+');
+
+describe('Entities', () => {
+
+    const theClass = fmxRep._getFamixClass("EntityClass");
+    const theSubclass = fmxRep._getFamixClass("class2");
+
+    it("should contain an EntityClass", () => {
+        const theClass = fmxRep._getFamixClass("EntityClass");
+        expect(theClass).toBeTruthy();
+    });
+
+    it("should contain an EntityClass with four methods", () => {
+        const theClass = fmxRep._getFamixClass("EntityClass");
+        if (theClass) expect(theClass.getMethods().size).toBe(4);
+    });
+
+    it("should contain methods with correct names", () => {
+        if (theClass) {
+            const mNames = fmxRep._methodNamesAsSetFromClass("EntityClass");    
+            expect(mNames.has("move") &&
+            mNames.has("move2") &&
+            mNames.has("constructor")).toBe(true);
+        } 
+    });
+
+    it("should contain a private method named move2 that returns void", () => {
+        if (theClass) {
+            const move2Method = fmxRep._getFamixMethod("move2");
+            expect(move2Method).toBeTruthy();
+            if (move2Method) {
+                expect(move2Method.getIsPrivate()).toBe(true);
+            }
+        } 
+    });
+   
+    it("should contain a private method named move2 with a signature 'private move2(family: string): void'", () => {
+        if (theClass) {
+            const move2Method = fmxRep._getFamixMethod("move2");
+            expect(move2Method).toBeTruthy();
+            if (move2Method) {
+                expect(move2Method.getSignature()).toBe('private move2(family: string): void');
+            }
+        } 
+    });
+
+    it("should contain a constructor in EntityClass", () => {
+        const theConstructor = fmxRep._getFamixMethod("constructor") as Method;
+        expect(theConstructor).toBeTruthy();
+        expect(theConstructor.getKind()).toBe("constructor");
+    });
+
+    it("should have a parent relationship between EntityClass and its methods", () => {
+        if (theClass) { 
+            const mParents = fmxRep._methodParentsAsSetFromClass("EntityClass");
+            expect(mParents.size).toBe(1);
+            expect(Array.from(mParents)[0]).toEqual(theClass);
+        }
+    });
+
+    it("should contain an EntityClass with eight attributes", () => {
+        expect(theClass?.getProperties().size).toBe(8);
+    });
+
+    it("should contain an EntityClass with an attribute named 'name' that is public", () => {
+        if (theClass) {
+            const nameAttribute = Array.from(theClass.getProperties())[0];
+            expect(nameAttribute.getName()).toBe("name");
+            expect(nameAttribute.getModifiers()).toContain("public");
+        }
+    });
+
+    it("should contain an EntityClass with an attribute named 'name' of type string", () => {
+        if (theClass) {
+            expect(Array.from(theClass.getProperties())[0].getDeclaredType().getName()).toBe("string");
+        }
+    });
+
+    it("should contain an EntityClass with an attribute named 'p1' that is private and of type boolean", () => {
+        if (theClass) {
+            const p1Attribute = Array.from(theClass.getProperties())[1];
+            expect(p1Attribute.getName()).toBe("p1");
+            expect(p1Attribute.getModifiers()).toContain("private");
+            expect(p1Attribute.getDeclaredType().getName()).toBe("boolean");
+        }
+    });
+
+    it("should contain an EntityClass with an attribute named '#p2' that is run-time private and of type boolean", () => {
+        if (theClass) {
+            const p2Attribute = Array.from(theClass.getProperties())[2];
+            expect(p2Attribute.getName()).toBe("#p2");
+            expect(p2Attribute.getDeclaredType().getName()).toBe("boolean");
+        }
+    });
+
+    it("should contain an EntityClass with an attribute named 'prot1' that is protected and of type Map<any, any>", () => {
+        if (theClass) {
+            const prot1Attribute = Array.from(theClass.getProperties())[3];
+            expect(prot1Attribute.getName()).toBe("prot1");
+            expect(prot1Attribute.getModifiers()).toContain("protected");
+            expect(prot1Attribute.getDeclaredType().getName()).toBe("Map<any, any>");
+        }
+    });
+
+    it("should contain an EntityClass with an attribute named 'trustMe' that is guaranteed to be there (!) and of type string", () => {
+        if (theClass) {
+            const trustMeAttribute = Array.from(theClass.getProperties())[4];
+            expect(trustMeAttribute.getName()).toBe("trustMe");
+            expect(trustMeAttribute.getModifiers()).toContain("!");
+            expect(trustMeAttribute.getDeclaredType().getName()).toBe("string");
+        }
+    });
+
+    it("should contain an EntityClass with an attribute named 'ro' that is readonly and of type \"yes\"", () => {
+        if (theClass) {
+            const roAttribute = Array.from(theClass.getProperties())[5];
+            expect(roAttribute.getName()).toBe("ro");
+            expect(roAttribute.getModifiers()).toContain("readonly");
+            expect(roAttribute.getDeclaredType().getName()).toBe('"yes"');
+        }
+    });
+
+    it("should contain an EntityClass with an attribute named '#userCount' that is static and of type number", () => {
+        if (theClass) {
+            const userCountAttribute = Array.from(theClass.getProperties())[6];
+            expect(userCountAttribute.getName()).toBe("#userCount");
+            expect(userCountAttribute.getModifiers()).toContain("static");
+            expect(userCountAttribute.getDeclaredType().getName()).toBe('number');
+        }
+    });
+
+    it("should contain an EntityClass with an attribute named 'optional' that is optional (?) and of type string", () => {
+        if (theClass) {
+            const userCountAttribute = Array.from(theClass.getProperties())[7];
+            expect(userCountAttribute.getName()).toBe("optional");
+            expect(userCountAttribute.getModifiers()).toContain("?");
+            expect(userCountAttribute.getDeclaredType().getName()).toBe('string');
+        }
+    });
+
+    it("should contain an EntityClass with one subclass", () => {
+        if (theClass) {
+            expect(Array.from(theClass.getSubInheritances()).length).toBe(1);
+        }
+    });
+
+    it("should contain an EntityClass with one subclass named 'class2'", () => {
+        if (theClass) {
+            const theClassSubclass = Array.from(theClass.getSubInheritances())[0].getSubclass();
+            expect(theClassSubclass.getName()).toBe("class2");
+            if (theSubclass) {
+                expect(theSubclass).toBe(theClassSubclass);
+            }
+        }
+    });
+
+    it("should contain a clsInNsp with a class-side method named 'aStaticMethod'", () => {
+        const clsInNSP = fmxRep._getFamixClass("clsInNsp");
+        expect(clsInNSP).toBeTruthy();
+        if (clsInNSP) {
+            const aStaticMethod = Array.from(clsInNSP.getMethods()).find(m => m.getName() === 'aStaticMethod');
+            expect(aStaticMethod).toBeTruthy();
+            if (aStaticMethod) {
+                expect(aStaticMethod.getIsClassSide()).toBe(true);
+            }
+        }
+    });
+
+    it("should contain a private method named '#move3'", () => {
+        const cls = fmxRep._getFamixClass("EntityClass");
+        expect(cls).toBeTruthy();
+        if (cls) {
+            const aMethod = Array.from(cls.getMethods()).find(m => m.getName() === '#move3');
+            expect(aMethod).toBeTruthy();
+            if (aMethod) {
+                expect(aMethod.getIsPrivate()).toBe(true);
+                expect(aMethod.getIsProtected()).toBe(false);
+                expect(aMethod.getIsPublic()).toBe(false);
+                expect(aMethod.getIsClassSide()).toBe(false);
+            }
+        }
+    });
+
+    // global scope
+    it("should contain a function 'globalFunc' with global scope", () => {
+        const globalFunc = fmxRep._getFamixFunction('globalFunc') as Function;
+        expect(globalFunc).toBeTruthy();
+        expect(globalFunc.getName()).toBe('globalFunc');
+        expect(globalFunc.getParentContainerEntity().getName()).toBe('entities.ts');
+    });
+
+    it("should contain a variable 'globalA' with global scope", () => {
+        const list = Array.from(fmxRep._getAllEntitiesWithType("Variable") as Set<Variable>);
+        expect(list).toBeTruthy();
+        const globalVar = list.find(p => p.getName() === "globalA");
+        expect(globalVar).toBeTruthy();
+    });
+});

package/test/entities_json.test.ts

@@ -0,0 +1,48 @@
+import { Importer } from '../src/analyze';
+import { Method } from '../src/lib/famix/src/model/famix';
+
+const importer = new Importer();
+
+const fmxRep = importer.famixRepFromSource("entities_json", 
+    'class EntityClass {\n\
+    constructor() {}\n\
+    public move() {}\n\
+    private move2() {}\n\
+}\n\
+');
+
+describe('Entities json', () => {
+
+    const jsonOutput = fmxRep.getJSON();
+    const parsedModel = JSON.parse(jsonOutput);
+
+    it("should generate valid json", () => { // smoke test parse (change to non-empty)
+        expect(parsedModel).toBeTruthy();
+    });
+
+    it("should generate json with FM3 FamixTypeScript.Class for EntityClass", () => {
+        expect(jsonOutput).toMatch(/"FM3":"FamixTypeScript.Class","id":[1-9]\d*|0,"sourceAnchor":{"ref":[1-9]\d*|0},"name":"EntityClass"/);
+    });
+
+    it("should contain an EntityClass with three methods", () => {
+        const theClass = parsedModel.filter(el => (el.FM3 === "FamixTypeScript.Class" && el.name === "EntityClass"))[0];
+        expect(theClass.methods.length).toBe(3);
+    });
+
+    it("should have three methods: move, move2 and constructor", () => { 
+        const theClass = parsedModel.filter(el => (el.FM3 === "FamixTypeScript.Class" && el.name === "EntityClass"))[0];
+        const mNames: Set<string> = new Set();
+        theClass.methods.forEach(m => {
+            const entityCls = fmxRep.getFamixEntityById(m.ref as number) as Method;
+            mNames.add(entityCls.getName());
+        });
+        expect(mNames.has("move") &&
+            mNames.has("move2") &&
+            mNames.has("constructor")).toBe(true);
+    });
+
+    it("should have method move", () => { 
+        const theMethod = parsedModel.filter(el => (el.FM3 === "FamixTypeScript.Method" && el.name === "move"))[0];
+        expect(theMethod).toBeTruthy();
+    });
+});

package/test/enum.test.ts

@@ -0,0 +1,55 @@
+import { Importer } from '../src/analyze';
+import { Access } from '../src/lib/famix/src/model/famix/access';
+import { Enum } from '../src/lib/famix/src/model/famix/enum';
+import { ScriptEntity } from '../src/lib/famix/src/model/famix/script_entity';
+
+const importer = new Importer();
+
+const fmxRep = importer.famixRepFromSource("enum", 
+    'enum Weekday {\n\
+    MONDAY = "Monday",\n\
+    TUESDAY = "Tuesday",\n\
+    WEDNESDAY = "Wednesday",\n\
+    THURSDAY = "Thursday",\n\
+    FRIDAY = "Friday",\n\
+    SATURDAY = "Saturday",\n\
+    SUNDAY = "Sunday"\n\
+}\n\
+\n\
+const aDay: Weekday = Weekday.MONDAY;\n\
+');
+
+describe('Tests for enum', () => {
+    
+    const theFile = Array.from(fmxRep._getAllEntitiesWithType("ScriptEntity") as Set<ScriptEntity>)[0];
+
+    it("should contain one enum with seven enum values", () => {
+        expect(fmxRep._getAllEntitiesWithType("Enum").size).toBe(1);
+        const theEnum = Array.from(fmxRep._getAllEntitiesWithType("Enum") as Set<Enum>)[0];
+        expect(theFile.getTypes().has(theEnum)).toBe(true);
+        expect(theEnum.getName()).toBe("Weekday");
+        expect(theEnum.getValues().size).toBe(7);
+        expect(Array.from(theEnum.getValues())[0].getName()).toBe("MONDAY");
+        expect(Array.from(theEnum.getValues())[1].getName()).toBe("TUESDAY");
+        expect(Array.from(theEnum.getValues())[2].getName()).toBe("WEDNESDAY");
+        expect(Array.from(theEnum.getValues())[3].getName()).toBe("THURSDAY");
+        expect(Array.from(theEnum.getValues())[4].getName()).toBe("FRIDAY");
+        expect(Array.from(theEnum.getValues())[5].getName()).toBe("SATURDAY");
+        expect(Array.from(theEnum.getValues())[6].getName()).toBe("SUNDAY");
+        expect(Array.from(theEnum.getValues())[0].getParentEntity()).toBe(theEnum);
+        expect(Array.from(theEnum.getValues())[1].getParentEntity()).toBe(theEnum);
+        expect(Array.from(theEnum.getValues())[2].getParentEntity()).toBe(theEnum);
+        expect(Array.from(theEnum.getValues())[3].getParentEntity()).toBe(theEnum);
+        expect(Array.from(theEnum.getValues())[4].getParentEntity()).toBe(theEnum);
+        expect(Array.from(theEnum.getValues())[5].getParentEntity()).toBe(theEnum);
+        expect(Array.from(theEnum.getValues())[6].getParentEntity()).toBe(theEnum);
+    });
+    
+    it("should contain one access", () => {
+        expect(fmxRep._getAllEntitiesWithType("Access").size).toBe(1);
+        const theAccess = Array.from(fmxRep._getAllEntitiesWithType("Access") as Set<Access>)[0];
+        expect(theFile.getAccesses().has(theAccess)).toBe(true);
+        expect(theAccess.getAccessor().getName()).toBe("enum.ts");
+        expect(theAccess.getVariable().getName()).toBe("MONDAY");
+    });    
+});

package/test/functionReturnsFunction.test.ts

@@ -0,0 +1,53 @@
+import { Importer } from '../src/analyze';
+import { Function } from "../src/lib/famix/src/model/famix/function";
+
+const importer = new Importer();
+
+const fmxRep = importer.famixRepFromSource("functionReturnsFunction", 
+    'export function deco() {\n\
+    function fct() {\n\
+        return function logMethod(target: any, propertyKey: string, descriptor: PropertyDescriptor) {\n\
+            const originalMethod = descriptor.value;\n\
+            descriptor.value = function (...args: any[]) {\n\
+                console.log(`Calling ${propertyKey} with arguments: ${JSON.stringify(args)}`);\n\
+                const result = originalMethod.apply(this, args);\n\
+                console.log(`Method ${propertyKey} returned: ${JSON.stringify(result)}`);\n\
+                return result;\n\
+            };\n\
+            return descriptor;\n\
+        };\n\
+    }\n\
+}\n\
+');
+
+describe('Tests for function returns function', () => {
+    
+    const functionList = fmxRep._getAllEntitiesWithType('Function');
+    it("should have four functions", () => {
+        expect(functionList?.size).toBe(4);
+    });
+
+    const theFunction = Array.from(functionList)[0] as Function;
+    it("should contain a function 'deco'", () => {
+        expect(theFunction).toBeTruthy();
+        expect(theFunction?.getName()).toBe('deco');
+    });
+
+    const theFunction2 = Array.from(functionList)[1] as Function;
+    it("should contain a function 'fct'", () => {
+        expect(theFunction2).toBeTruthy();
+        expect(theFunction2?.getName()).toBe('fct');
+    });
+
+    const theFunction3 = Array.from(functionList)[2] as Function;
+    it("should contain a function 'logMethod'", () => {
+        expect(theFunction3).toBeTruthy();
+        expect(theFunction3?.getName()).toBe('logMethod');
+    });
+
+    const theFunction4 = Array.from(functionList)[3] as Function;
+    it("should contain a function 'anonymous'", () => {
+        expect(theFunction4).toBeTruthy();
+        expect(theFunction4?.getName()).toBe('anonymous');
+    });
+});

package/test/functionWithParameters.test.ts

@@ -0,0 +1,38 @@
+import { Importer } from '../src/analyze';
+import { Function } from "../src/lib/famix/src/model/famix/function";
+
+const importer = new Importer();
+
+const fmxRep = importer.famixRepFromSource("functionWithParameters", 
+    'function fct(i: number, x: string): number {\n\
+    return 0;\n\
+}\n\
+');
+
+describe('Tests for function with parameters', () => {
+    
+    const theFunction = Array.from(fmxRep._getAllEntitiesWithType('Function'))[0] as Function;
+    it("should have two parameters", () => {
+        expect(theFunction?.getParameters().size).toBe(2);
+    });
+
+    const firstParam = Array.from(theFunction?.getParameters()).find((p) => p.getName() === "i");
+    it("should have a parameter 'i'", () => {
+        expect(firstParam).toBeTruthy();
+    });
+
+    it("should be of type number", () => {
+        expect(firstParam?.getDeclaredType().getName()).toBe("number");
+        expect(firstParam?.getParentEntity()).toBe(theFunction);
+    });
+
+    const secondParam = Array.from(theFunction?.getParameters()).find((p) => p.getName() === "x");
+    it("should have a parameter 'x'", () => {
+        expect(secondParam).toBeTruthy();
+    });
+
+    it("should be of type string", () => {
+        expect(secondParam?.getDeclaredType().getName()).toBe("string");
+        expect(secondParam?.getParentEntity()).toBe(theFunction);
+    });
+});

package/test/functionWithVariables.test.ts

@@ -0,0 +1,64 @@
+import { Importer } from '../src/analyze';
+import { Function } from "../src/lib/famix/src/model/famix/function";
+import { Comment } from '../src/lib/famix/src/model/famix/comment';
+
+const importer = new Importer();
+
+const fmxRep = importer.famixRepFromSource("functionWithVariables", 
+    'function fct(): number {\n\
+    // comment 1\n\
+    let i: number /*comment 2*/, j: number; // comment 3\n\
+    const x: string = "";\n\
+    return 0;\n\
+}\n\
+');
+
+describe('Tests for function with variables', () => {
+    
+    const theFunction = Array.from(fmxRep._getAllEntitiesWithType('Function'))[0] as Function;
+    it("should have three variables", () => {
+        expect(theFunction?.getVariables().size).toBe(3);
+    });
+
+    const firstVariable = Array.from(theFunction?.getVariables()).find((p) => p.getName() === "i");
+    it("should have a variable 'i' with three comments", () => {
+        expect(firstVariable).toBeTruthy();
+        expect(firstVariable?.getParentContainerEntity()).toBe(theFunction);
+        expect(firstVariable?.getComments().size).toBe(3);
+        expect(Array.from(firstVariable?.getComments() as Set<Comment>)[0]?.getContent()).toBe("/*comment 2*/");
+        expect(Array.from(firstVariable?.getComments() as Set<Comment>)[1]?.getContent()).toBe("// comment 1");
+        expect(Array.from(firstVariable?.getComments() as Set<Comment>)[2]?.getContent()).toBe("// comment 3");
+        expect(Array.from(firstVariable?.getComments() as Set<Comment>)[0]?.getContainer()).toBe(firstVariable);
+        expect(Array.from(firstVariable?.getComments() as Set<Comment>)[1]?.getContainer()).toBe(firstVariable);
+        expect(Array.from(firstVariable?.getComments() as Set<Comment>)[2]?.getContainer()).toBe(firstVariable);
+    });
+
+    it("should be of type number", () => {
+        expect(firstVariable?.getDeclaredType().getName()).toBe("number");
+    });
+
+    const secondVariable = Array.from(theFunction?.getVariables()).find((p) => p.getName() === "j");
+    it("should have a variable 'j' with two comments", () => {
+        expect(secondVariable).toBeTruthy();
+        expect(secondVariable?.getParentContainerEntity()).toBe(theFunction);
+        expect(secondVariable?.getComments().size).toBe(2);
+        expect(Array.from(secondVariable?.getComments() as Set<Comment>)[0]?.getContent()).toBe("// comment 1");
+        expect(Array.from(secondVariable?.getComments() as Set<Comment>)[1]?.getContent()).toBe("// comment 3");
+        expect(Array.from(secondVariable?.getComments() as Set<Comment>)[0]?.getContainer()).toBe(secondVariable);
+        expect(Array.from(secondVariable?.getComments() as Set<Comment>)[1]?.getContainer()).toBe(secondVariable);
+    });
+    
+    it("should be of type number", () => {
+        expect(secondVariable?.getDeclaredType().getName()).toBe("number");
+    });
+
+    const thirdVariable = Array.from(theFunction?.getVariables()).find((p) => p.getName() === "x");
+    it("should have a variable 'x'", () => {
+        expect(thirdVariable).toBeTruthy();
+        expect(thirdVariable?.getParentContainerEntity()).toBe(theFunction);
+    });
+
+    it("should be of type string", () => {
+        expect(thirdVariable?.getDeclaredType().getName()).toBe("string");
+    });
+});

package/test/functions.test.ts

@@ -0,0 +1,23 @@
+import { Importer } from '../src/analyze';
+
+const importer = new Importer();
+
+const fmxRep = importer.famixRepFromSource("functions", 
+    'function a() {}\n\
+function b() {}\n\
+');
+
+describe('Functions', () => {
+
+    it("should contain function 'a'", () => {
+        const functionName = "a";
+        const theFunction = fmxRep._getFamixFunction(functionName);
+        expect(theFunction).toBeTruthy();
+    });
+
+    it("should contain function 'b'", () => {
+        const functionName = "b";
+        const theFunction = fmxRep._getFamixFunction(functionName);
+        expect(theFunction).toBeTruthy();
+    });
+});

package/test/functionsInFunction.test.ts

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

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

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