ts2famix 1.0.1 → 1.0.4

package/test/classExtendsUndefinedClass.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("classExtendsUndefinedClass", 
-    'import {ClassDeclaration} from "ts-morph";\n\
-\n\
-class myClass extends ClassDeclaration {}\n\
-');
-
-describe('Tests for class extends undefined class', () => {
-
-    it("should contain two class", () => {
-        expect(fmxRep._getAllEntitiesWithType("Class").size).toBe(2);
-    });
-
-    it("should contain a class myClass that extends a class ClassDeclaration", () => {
-        const cList = Array.from(fmxRep._getAllEntitiesWithType("Class") as Set<Interface>);
-        expect(cList).toBeTruthy();
-        const myClass1 = cList.find(p => p.getName() === "ClassDeclaration");
-        expect(myClass1).toBeTruthy();
-        expect(myClass1?.getIsStub()).toBe(true);
-        const myClass2 = cList.find(p => p.getName() === "myClass");
-        expect(myClass2).toBeTruthy();
-        if (myClass2) {
-            expect(myClass2.getSubInheritances().size).toBe(0);
-            expect(myClass2.getSuperInheritances().size).toBe(1);
-            const theInheritance = (Array.from(myClass2.getSuperInheritances())[0]);
-            expect(theInheritance.getSuperclass()).toBeTruthy();
-            expect(theInheritance.getSuperclass()).toBe(myClass1);
-        }
-        if (myClass1) {
-            expect(myClass1.getSubInheritances().size).toBe(1);
-            expect(myClass1.getSuperInheritances().size).toBe(0);
-            const theInheritance = (Array.from(myClass1.getSubInheritances())[0]);
-            expect(theInheritance.getSubclass()).toBeTruthy();
-            expect(theInheritance.getSubclass()).toBe(myClass2);
-        }
-    });
-});

package/test/classImplementsUndefinedInterface.test.ts

@@ -1,45 +0,0 @@
-import { Importer } from '../src/analyze';
-import { Class } from '../src/lib/famix/src/model/famix/class';
-import { Interface } from '../src/lib/famix/src/model/famix/interface';
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("classImplementsUndefinedInterface", 
-    'import {FileSystemHost} from "ts-morph";\n\
-\n\
-class myClass implements FileSystemHost {}\n\
-');
-
-describe('Tests for class implements undefined interface', () => {
-
-    it("should contain one class and one interface", () => {
-        expect(fmxRep._getAllEntitiesWithType("Class").size).toBe(1);
-        expect(fmxRep._getAllEntitiesWithType("Interface").size).toBe(1);
-    });
-
-    it("should contain an interface myClass that extends an interface FileSystemHost", () => {
-        const cList = Array.from(fmxRep._getAllEntitiesWithType("Class") as Set<Class>);
-        const iList = Array.from(fmxRep._getAllEntitiesWithType("Interface") as Set<Interface>);
-        expect(cList).toBeTruthy();
-        expect(iList).toBeTruthy();
-        const myInterface1 = iList.find(p => p.getName() === "FileSystemHost");
-        expect(myInterface1).toBeTruthy();
-        expect(myInterface1?.getIsStub()).toBe(true);
-        const myClass = cList.find(p => p.getName() === "myClass");
-        expect(myClass).toBeTruthy();
-        if (myClass) {
-            expect(myClass.getSubInheritances().size).toBe(0);
-            expect(myClass.getSuperInheritances().size).toBe(1);
-            const theInheritance = (Array.from(myClass.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(myClass);
-        }
-    });
-});

package/test/classWithDecorators.test.ts

@@ -1,65 +0,0 @@
-import { Importer } from '../src/analyze';
-import { Decorator } from '../src/lib/famix/src/model/famix/decorator';
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("classWithDecorators", 
-    'function sealed(constructor: Function) { // function can\'t take other parameters with constructor\n\
-    Object.seal(constructor);\n\
-    Object.seal(constructor.prototype);\n\
-}\n\
-\n\
-function reportableClassDecorator<T extends { new (...args: any[]): {} }>(constructor: T) {\n\
-    return class extends constructor {\n\
-        reportingURL = "http://www...";\n\
-    };\n\
-}\n\
-\n\
-// the signature is different from the one of the other decorators\n\
-var d = function decoratorWithParameter(parameter: string) {\n\
-    return function (target: Function) {\n\
-        // use parameter in decorator behavior\n\
-        console.log("Decorator parameter :", parameter);\n\
-    };\n\
-};\n\
-\n\
-var c = d("param2");\n\
-\n\
-@c\n\
-@d("param")\n\
-@sealed\n\
-@reportableClassDecorator\n\
-class BugReport {\n\
-    type = "report";\n\
-    title: string;\n\
-    \n\
-    constructor(t: string) {\n\
-        this.title = t;\n\
-    }\n\
-}\n\
-');
-
-describe('Tests for class with decorators', () => {
-    
-    it("should contain one class", () => {
-        expect(fmxRep._getAllEntitiesWithType("Class").size).toBe(1);
-    });
-
-    it("should contain four decorators", () => {
-        expect(fmxRep._getAllEntitiesWithType("Decorator").size).toBe(4);
-    });
-
-    const theClass = fmxRep._getFamixClass("BugReport");
-    const d1 = (Array.from(fmxRep._getAllEntitiesWithType("Decorator")) as Array<Decorator>).find((d) => d.getName() === "@c");
-    const d2 = (Array.from(fmxRep._getAllEntitiesWithType("Decorator")) as Array<Decorator>).find((d) => d.getName() === "@d");
-    const d3 = (Array.from(fmxRep._getAllEntitiesWithType("Decorator")) as Array<Decorator>).find((d) => d.getName() === "@sealed");
-    const d4 = (Array.from(fmxRep._getAllEntitiesWithType("Decorator")) as Array<Decorator>).find((d) => d.getName() === "@reportableClassDecorator");
-
-    it("should contain a class with four decorators", () => {
-        expect(theClass?.getDecorators().size).toBe(4);
-        expect(d1?.getDecoratedEntity()).toBe(theClass);
-        expect(d2?.getDecoratedEntity()).toBe(theClass);
-        expect(d3?.getDecoratedEntity()).toBe(theClass);
-        expect(d4?.getDecoratedEntity()).toBe(theClass);
-    });
-});

package/test/entities.test.ts

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

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

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

@@ -1,53 +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("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

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

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

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