ts2famix 1.0.1 → 1.0.5

package/test/invocationWithFunction.test.ts

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

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

package/test/invocation_json.test.ts

@@ -1,63 +0,0 @@
-import { Importer } from '../src/analyze';
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("invocation_json", 
-    'class Class1 {\n\
-    public returnHi() {}\n\
-}\n\
-\n\
-class Class2 {\n\
-    public returnName() {}\n\
-}\n\
-\n\
-class Class3 {\n\
-    public getString() {\n\
-        var class1Obj = new Class1();\n\
-        var class2Obj = new Class2();\n\
-        var returnValue1 = class1Obj.returnHi();\n\
-        var returnValue2 = class2Obj.returnName();\n\
-    }\n\
-}\n\
-');
-
-describe('Invocations json', () => {
-
-    const jsonOutput = fmxRep.getJSON();
-    const parsedModel = JSON.parse(jsonOutput);
-
-    it("should contain a class Class3 with one method: getString", () => {
-        const invocationCls = parsedModel.filter(el => (el.FM3 === "FamixTypeScript.Class" && el.name === "Class3"))[0];
-        expect(invocationCls.methods.length).toBe(1);
-        const methodNames: Array<string> = ['getString'];
-        const invocationClsMethods = parsedModel.filter(e => invocationCls.methods.some(m => m.ref === e.id));
-        expect(invocationClsMethods.length).toBeGreaterThan(0);
-        const checkMethodName = invocationClsMethods.every(m => methodNames.includes(m.name));
-        expect(checkMethodName).toBe(true);
-    });
-
-    it("should have one invocation for method returnHi in Class1",  () => {
-        verifyInvocation(parsedModel, "Class1", "returnHi");
-    });
-
-    it("should have one invocation for method returnName in Class2",  () => {
-        verifyInvocation(parsedModel, "Class2", "returnName");
-    });
-});
-
-function verifyInvocation(parsedModel: any, theClass: string, theMethod: string) {
-    const invocationCls = parsedModel.filter(el => (el.FM3 === "FamixTypeScript.Class" && el.name === theClass))[0];
-    const invocationClsMethods = parsedModel.filter(e => invocationCls.methods.some(m => m.ref === e.id));
-    const methodNames: Array<string> = [theMethod];
-    invocationClsMethods.forEach(m => expect(methodNames).toContain(m.name));
-    const foundMethods = invocationClsMethods.filter(m => methodNames.includes(m.name));
-    expect(foundMethods.length).toBe(1);
-    const checkMethodHasInvocation = foundMethods.every(m => m.incomingInvocations !== undefined);
-    expect(checkMethodHasInvocation).toBe(true);
-    invocationClsMethods.forEach(method => {
-        const invocationCls = parsedModel.filter(e => e.FM3 === "FamixTypeScript.Invocation"
-            && method.incomingInvocations.some(m => m.ref === e.id));
-        const checkHasRelatedToMethod = invocationCls.every(a => a.candidates.length && a.candidates[0].ref === method.id);
-        expect(checkHasRelatedToMethod).toBe(true);
-    });
-}

package/test/invocations.test.ts

@@ -1,131 +0,0 @@
-import { Importer } from '../src/analyze';
-import { Invocation, Method } from "../src/lib/famix/src/model/famix";
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("invocations", 
-    'class Class1 {\n\
-    public returnHi(): string {\n\
-        return "Hi";\n\
-    }\n\
-}\n\
-\n\
-class Class2 {\n\
-    public returnName() {}\n\
-}\n\
-\n\
-class Class3 {\n\
-    public getString() {\n\
-        var class1Obj = new Class1();\n\
-        var class2Obj = new Class2();\n\
-        var returnValue1 = class1Obj.returnHi();\n\
-        var returnValue2 = class2Obj.returnName();\n\
-        var x = a();\n\
-    }\n\
-}\n\
-\n\
-function a() {}\n\
-');
-
-describe('Invocations', () => {
-
-    it("should contain method returnHi in Class1", () => {
-        const clsName = "Class1";
-        const mName = "returnHi";
-        const theClass = fmxRep._getFamixClass(clsName);
-        expect(theClass).toBeTruthy();
-        if (theClass) {
-            const methodFqn = Array.from(theClass.getMethods())[0].getFullyQualifiedName();
-            expect(methodFqn.substring(methodFqn.length-clsName.length-1-mName.length)).toBe(clsName + '.' + mName);
-            const theMethod = fmxRep.getFamixEntityByFullyQualifiedName(methodFqn);
-            expect(theMethod).toBeTruthy();    
-        }
-    });
-
-    it("should contain method returnName in Class2", () => {
-        const clsName = "Class2";
-        const mName = "returnName";
-        const theClass = fmxRep._getFamixClass(clsName);
-        expect(theClass).toBeTruthy();
-        if (theClass) {
-            const methodFqn = Array.from(theClass.getMethods())[0].getFullyQualifiedName();
-            expect(methodFqn.substring(methodFqn.length-clsName.length-1-mName.length)).toBe(clsName + '.' + mName);
-            const theMethod = fmxRep.getFamixEntityByFullyQualifiedName(methodFqn);
-            expect(theMethod).toBeTruthy();    
-        }
-    });
-
-    it("should contain method getString in Class3", () => {
-        const clsName = "Class3";
-        const mName = "getString";
-        const theClass = fmxRep._getFamixClass(clsName);
-        expect(theClass).toBeTruthy();
-        if (theClass) {
-            const methodFqn = Array.from(theClass.getMethods())[0].getFullyQualifiedName();
-            expect(methodFqn.substring(methodFqn.length-clsName.length-1-mName.length)).toBe(clsName + '.' + mName);
-            const theMethod = fmxRep.getFamixEntityByFullyQualifiedName(methodFqn);
-            expect(theMethod).toBeTruthy();    
-        }
-    });
-
-    it("should contain an invocation for returnHi", () => {
-        const clsName = "Class1";
-        const theClass = fmxRep._getFamixClass(clsName);
-        expect(theClass).toBeTruthy();
-        if (theClass) {
-            const methodFqn = Array.from(theClass.getMethods())[0].getFullyQualifiedName();
-            const theMethod = fmxRep.getFamixEntityByFullyQualifiedName(methodFqn) as Method;
-            expect(theMethod).toBeTruthy();
-            const invocations = Array.from(fmxRep._getAllEntitiesWithType("Invocation"));
-            expect(invocations).toBeTruthy();
-            expect(invocations.length).toBeTruthy();
-            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 returnHi with a receiver of 'Class1'", () => {
-        const clsName = "Class1";
-        const theClass = fmxRep._getFamixClass(clsName);
-        expect(theClass).toBeTruthy();
-        if (theClass) {
-            const methodFqn = Array.from(theClass.getMethods())[0].getFullyQualifiedName();
-            const theMethod = fmxRep.getFamixEntityByFullyQualifiedName(methodFqn) as Method;
-            expect(theMethod).toBeTruthy();
-            const invocations = Array.from(fmxRep._getAllEntitiesWithType("Invocation"));
-            expect(invocations).toBeTruthy();
-            expect(invocations.length).toBeTruthy();
-            expect((invocations[0] as Invocation).getReceiver()).toBeTruthy();
-            expect((invocations[0] as Invocation).getReceiver()).toBe(fmxRep._getFamixClass("Class1"));
-        }
-    });
-
-    it("should contain an invocation for returnHi with a signature 'public returnHi(): string'", () => {
-        const clsName = "Class1";
-        const theClass = fmxRep._getFamixClass(clsName);
-        expect(theClass).toBeTruthy();
-        if (theClass) {
-            const methodFqn = Array.from(theClass.getMethods())[0].getFullyQualifiedName();
-            const theMethod = fmxRep.getFamixEntityByFullyQualifiedName(methodFqn) as Method;
-            expect(theMethod).toBeTruthy();
-            const invocations = Array.from(fmxRep._getAllEntitiesWithType("Invocation"));
-            expect(invocations).toBeTruthy();
-            expect(invocations.length).toBeTruthy();
-            expect((invocations[0] as Invocation).getSignature()).toBeTruthy();
-            expect((invocations[0] as Invocation).getSignature()).toBe('public returnHi(): string');
-        }
-    });
-
-    it("should contain an invocation for a function 'a'", () => {
-        const theFunction = fmxRep._getFamixFunction("a");
-        expect(theFunction).toBeTruthy();
-        const invocations = Array.from(fmxRep._getAllEntitiesWithType("Invocation"));
-        expect(invocations).toBeTruthy();
-        expect(invocations.length).toBeTruthy();
-        expect((invocations[0] as Invocation).getSignature()).toBeTruthy();
-        expect((invocations[0] as Invocation).getSignature()).toBe('public returnHi(): string');
-    });
-});

package/test/jsDoc.test.ts

@@ -1,31 +0,0 @@
-import { Importer } from '../src/analyze';
-import { Comment } from '../src/lib/famix/src/model/famix/comment';
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("jsDoc", 
-    '/**\n\
-* Gets the name.\n\
-* @param person - Person to get the name from.\n\
-*/\n\
-function getName(person: string) {}\n\
-');
-
-describe('Tests for JS doc', () => {
-    
-    it("should contain one function and one comment", () => {
-        expect(fmxRep._getAllEntitiesWithType("Function").size).toBe(1);
-        expect(fmxRep._getAllEntitiesWithType("Comment").size).toBe(1);
-    });
-
-    const theFunction = fmxRep._getFamixFunction("getName");
-    const theJSDoc = Array.from(fmxRep._getAllEntitiesWithType("Comment") as Set<Comment>)[0];
-
-    it("should have one comment for the function", () => {
-        expect(theFunction?.getComments().size).toBe(1);
-        expect(theFunction?.getComments().has(theJSDoc)).toBe(true);
-        expect(theJSDoc?.getContent()).toBe("/**\n* Gets the name.\n* @param person - Person to get the name from.\n*/");
-        expect(theJSDoc?.getContainer()).toBe(theFunction);
-        expect(theJSDoc?.getIsJSDoc()).toBe(true);
-    });
-});

package/test/methodWithDecorator.test.ts

@@ -1,44 +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("methodWithDecorator",
-    'function first() {\n\
-    console.log("first(): factory evaluated");\n\
-    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {\n\
-        console.log("first(): called");\n\
-    };\n\
-}\n\
-\n\
-class ExampleClass {\n\
-    @first()\n\
-    method() {}\n\
-}\n\
-');
-
-describe('Tests for method with decorator', () => {
-    
-    it("should contain one class", () => {
-        expect(fmxRep._getAllEntitiesWithType("Class").size).toBe(1);
-    });
-
-    it("should contain a method 'method'", () => {
-        expect(fmxRep._getAllEntitiesWithType("Method").size).toBe(1);
-        const theMethod = fmxRep._getFamixMethod("method");
-        expect(theMethod).toBeTruthy();
-    });
-
-    it("should contain one decorator", () => {
-        expect(fmxRep._getAllEntitiesWithType("Decorator").size).toBe(1);
-    });
-
-    const theMethod = fmxRep._getFamixMethod("method");
-    const d = (Array.from(fmxRep._getAllEntitiesWithType("Decorator")) as Array<Decorator>).find((d) => d.getName() === "@first");
-
-    it("should contain a method with one decorator", () => {
-        expect(theMethod?.getDecorators().size).toBe(1);
-        expect(d?.getDecoratedEntity()).toBe(theMethod);
-        expect(d?.getDecoratorExpression()).toBe("first()");
-    });
-});

package/test/methods.test.ts

@@ -1,42 +0,0 @@
-import { Importer } from '../src/analyze';
-import { Method } from "../src/lib/famix/src/model/famix/method";
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("methods", 
-    'class AAA {\n\
-    public method(): void {}\n\
-}\n\
-');
-
-describe('Tests for methods', () => {
-    
-    const methodList = fmxRep._getAllEntitiesWithType('Method');
-    it("should have method", () => {
-        expect(methodList?.size).toBe(1);
-    });
-
-    const theMethod = Array.from(methodList)[0] as Method;
-    it("should contain a method 'method'", () => {
-        expect(theMethod).toBeTruthy();
-        expect(theMethod?.getName()).toBe('method');
-    });
-
-
-    it("should return void", () => {
-        expect(theMethod?.getDeclaredType().getName()).toBe("void");
-    });
-
-    it("should have no parameter", () => {
-        expect(theMethod?.getParameters().size).toBe(0);
-    });
-
-    it("should be a public method 'method", () => {
-        expect(theMethod.getKind()).toBe(undefined);
-        expect(theMethod.getIsAbstract()).toBe(false);
-        expect(theMethod.getIsClassSide()).toBe(false);
-        expect(theMethod.getIsPrivate()).toBe(false);
-        expect(theMethod.getIsProtected()).toBe(false);
-        expect(theMethod.getIsPublic()).toBe(true);
-    });
-});

package/test/metrics.test.ts

@@ -1,51 +0,0 @@
-import { Importer } from '../src/analyze';
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("metrics", 
-    'class ForMetrics {\n\
-    public methodCyclomaticOne() {}\n\
-    \n\
-    public methodCyclomaticFour() {\n\
-        // make higher cyclomatic complexity\n\
-        for (let i = 0; i < 50; i++) { // 2\n\
-            for (let j = 0; j < 50; j++) { // 3\n\
-                if (i < 10) {} // 4\n\
-            }\n\
-        }\n\
-    }\n\
-}\n\
-\n\
-function functionCyclomaticOne() {}\n\
-\n\
-function functionCyclomaticFour() {\n\
-    // make higher cyclomatic complexity\n\
-    for (let i = 0; i < 50; i++) { // 2\n\
-        for (let j = 0; j < 50; j++) { // 3\n\
-            if (i < 10) {} // 4\n\
-        }\n\
-    }\n\
-}\n\
-');
-
-describe('Metrics', () => {
-
-    const jsonOutput = fmxRep.getJSON();
-    const parsedModel = JSON.parse(jsonOutput);
-
-    it("should calculate cyclomatic complexity", () => {
-        let theMethod = parsedModel.filter(el => (el.FM3 === "FamixTypeScript.Method" && el.name === "methodCyclomaticOne"))[0];
-        expect(theMethod).toBeTruthy();
-        expect(theMethod.cyclomaticComplexity).toBe(1);
-        theMethod = parsedModel.filter(el => (el.FM3 === "FamixTypeScript.Method" && el.name === "methodCyclomaticFour"))[0];
-        expect(theMethod).toBeTruthy();
-        expect(theMethod.cyclomaticComplexity).toBe(4);
-
-        let theFunction = parsedModel.filter(el => (el.FM3 === "FamixTypeScript.Function" && el.name === "functionCyclomaticOne"))[0];
-        expect(theFunction).toBeTruthy();
-        expect(theFunction.cyclomaticComplexity).toBe(1);
-        theFunction = parsedModel.filter(el => (el.FM3 === "FamixTypeScript.Function" && el.name === "functionCyclomaticFour"))[0];
-        expect(theFunction).toBeTruthy();
-        expect(theFunction.cyclomaticComplexity).toBe(4);
-    });
-});

package/test/module.test.ts

@@ -1,71 +0,0 @@
-import { Importer } from '../src/analyze';
-import { ImportClause } from '../src/lib/famix/src/model/famix/import_clause';
-import { Module } from '../src/lib/famix/src/model/famix/module';
-
-const importer = new Importer();
-
-const filePaths = new Array<string>();
-filePaths.push("test_src/sampleForModule.ts");
-filePaths.push("test_src/sampleForModule2.ts");
-filePaths.push("test_src/sampleForModule3.ts");
-
-const fmxRep = importer.famixRepFromPaths(filePaths);
-
-describe('Tests for module', () => {
-    
-    const moduleList = Array.from(fmxRep._getAllEntitiesWithType('Module')) as Array<Module>;
-    const theFile = moduleList.find(e => e.getName() === 'sampleForModule.ts');
-    const theFile2 = moduleList.find(e => e.getName() === 'sampleForModule2.ts');
-    const theFile3 = moduleList.find(e => e.getName() === 'sampleForModule3.ts');
-    it("should have three modules", () => {
-        expect(moduleList?.length).toBe(3);
-        expect(theFile).toBeTruthy();
-        expect(theFile2).toBeTruthy();
-        expect(theFile3).toBeTruthy();
-    });
-
-    const theClass = fmxRep._getFamixClass('ClassZ');
-    const importClauseList = Array.from(fmxRep._getAllEntitiesWithType('ImportClause')) as Array<ImportClause>;
-    it("should have ten import clauses", () => {
-        expect(importClauseList?.length).toBe(10);
-        expect(theFile2?.getImportClauses().size).toBe(8);
-        expect(theFile3?.getImportClauses().size).toBe(2);
-
-        const theImportClause = importClauseList.find(e => e.getImporter().getName() === 'sampleForModule2.ts' && e.getImportedEntity().getName() === 'ClassDeclaration' && e.getModuleSpecifier() === 'ts-morph');
-        expect(theImportClause).toBeTruthy();
-        const entity = theImportClause?.getImportedEntity();
-        expect(entity?.getName()).toBe('ClassDeclaration');
-        expect(entity?.getIsStub()).toBe(true);
-
-        const theImportClause2 = importClauseList.find(e => e.getImporter().getName() === 'sampleForModule2.ts' && e.getImportedEntity().getName() === 'ConstructorDeclaration' && e.getModuleSpecifier() === 'ts-morph');
-        expect(theImportClause2).toBeTruthy();
-        const entity2 = theImportClause2?.getImportedEntity();
-        expect(entity2?.getName()).toBe('ConstructorDeclaration');
-        expect(entity2?.getIsStub()).toBe(true);
-
-        const theImportClause3 = importClauseList.find(e => e.getImporter().getName() === 'sampleForModule2.ts' && e.getImportedEntity().getName() === 'Importer' && e.getModuleSpecifier() === '../test_src/sampleForModule');
-        expect(theImportClause3).toBeTruthy();
-
-        const theImportClause4 = importClauseList.find(e => e.getImporter().getName() === 'sampleForModule2.ts' && e.getImportedEntity().getName() === 'ClassZ' && e.getModuleSpecifier() === '../test_src/sampleForModule');
-        expect(theImportClause4).toBeTruthy();
-        expect(theImportClause4?.getImportedEntity()).toBe(theClass);
-
-        const theImportClause5 = importClauseList.find(e => e.getImporter().getName() === 'sampleForModule2.ts' && e.getImportedEntity().getName() === 'Cls' && e.getModuleSpecifier() === '../test_src/sampleForModule');
-        expect(theImportClause5).toBeTruthy();
-
-        const theImportClause6 = importClauseList.find(e => e.getImporter().getName() === 'sampleForModule2.ts' && e.getImportedEntity().getName() === 'Nsp' && e.getModuleSpecifier() === '../test_src/sampleForModule');
-        expect(theImportClause6).toBeTruthy();
-
-        const theImportClause7 = importClauseList.find(e => e.getImporter().getName() === 'sampleForModule2.ts' && e.getImportedEntity().getName() === 'Famix' && e.getModuleSpecifier() === '../src/lib/famix/src/model/famix');
-        expect(theImportClause7).toBeTruthy();
-
-        const theImportClause8 = importClauseList.find(e => e.getImporter().getName() === 'sampleForModule2.ts' && e.getImportedEntity().getName() === 'express' && e.getModuleSpecifier() === 'express');
-        expect(theImportClause8).toBeTruthy();
-
-        const theImportClause9 = importClauseList.find(e => e.getImporter().getName() === 'sampleForModule3.ts' && e.getImportedEntity().getName() === 'ClassX' && e.getModuleSpecifier() === 'express.ts');
-        expect(theImportClause9).toBeTruthy();
-
-        const theImportClause10 = importClauseList.find(e => e.getImporter().getName() === 'sampleForModule3.ts' && e.getImportedEntity().getName() === 'test' && e.getModuleSpecifier() === './sampleForModule.ts');
-        expect(theImportClause10).toBeTruthy();
-    });
-});

package/test/namespaces.test.ts

@@ -1,54 +0,0 @@
-import { Importer } from '../src/analyze';
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("namespaces", 
-    'namespace MyNamespace {}\n\
-\n\
-module MyModule {}\n\
-\n\
-declare module aModule {}\n\
-\n\
-declare module "someModule" {}\n\
-\n\
-declare module "otherModule";\n\
-\n\
-declare namespace MyNamespace2 {}\n\
-');
-
-describe('Tests for namespaces', () => {
-    
-    it("should contain six namespaces", () => {
-        expect(fmxRep._getFamixNamespaces().size).toBe(6);
-    });
-
-    const theNamespace1 = fmxRep._getFamixNamespace("MyNamespace");
-    it("should contain a namespace MyNamespace", () => {
-        expect(theNamespace1).toBeTruthy();
-    });
-
-    const theNamespace2 = fmxRep._getFamixNamespace("MyModule");
-    it("should contain a namespace MyModule", () => {
-        expect(theNamespace2).toBeTruthy();
-    });
-
-    const theNamespace3 = fmxRep._getFamixNamespace("aModule");
-    it("should contain a namespace aModule", () => {
-        expect(theNamespace3).toBeTruthy();
-    });
-
-    const theNamespace4 = fmxRep._getFamixNamespace("\"someModule\"");
-    it("should contain a namespace \"someModule\"", () => {
-        expect(theNamespace4).toBeTruthy();
-    });
-
-    const theNamespace5 = fmxRep._getFamixNamespace("\"otherModule\"");
-    it("should contain a namespace \"otherModule\"", () => {
-        expect(theNamespace5).toBeTruthy();
-    });
-
-    const theNamespace6 = fmxRep._getFamixNamespace("MyNamespace2");
-    it("should contain a namespace MyNamespace2", () => {
-        expect(theNamespace6).toBeTruthy();
-    });
-});

package/test/namespacesAndClasses.test.ts

@@ -1,66 +0,0 @@
-import { Importer } from '../src/analyze';
-import { Type } from '../src/lib/famix/src/model/famix/type';
-import { Class } from '../src/lib/famix/src/model/famix/class';
-
-const importer = new Importer();
-
-const fmxRep = importer.famixRepFromSource("namespacesAndClasses", 
-    'namespace MyNamespace {\n\
-	class EntityClass {}\n\
-	class class2 {}\n\
-}\n\
-\n\
-class clsOutNsp {}\n\
-\n\
-namespace Nsp3 {\n\
-	class clsInNsp3 {}\n\
-}\n\
-');
-
-describe('Tests for namespaces and classes', () => {
-    
-    it("should contain two namespaces", () => {
-        expect(fmxRep._getFamixNamespaces().size).toBe(2);
-    });
-
-    const theFile = fmxRep._getFamixFile("namespacesAndClasses.ts");
-    const theNamespace1 = fmxRep._getFamixNamespace("MyNamespace");
-    it("should contain a namespace MyNamespace", () => {
-        expect(theNamespace1).toBeTruthy();
-        expect(theNamespace1?.getParentScope()).toBe(theFile);
-    });
-
-    it("should contain two classes", () => {
-        expect(Array.from(theNamespace1?.getTypes() as Set<Type>).filter(t => (t instanceof Class)).length).toBe(2);
-    });
-
-    const theNamespace2 = fmxRep._getFamixNamespace("Nsp3");
-    it("should contain a namespace Nsp3", () => {
-        expect(theNamespace2).toBeTruthy();
-        expect(theNamespace2?.getParentScope()).toBe(theFile);
-    });
-    
-    it("should contain one class", () => {
-        expect(Array.from(theNamespace2?.getTypes() as Set<Type>).filter(t => (t instanceof Class)).length).toBe(1);
-    });
-
-    it("should contain four classes", () => {
-        expect(fmxRep._getAllEntitiesWithType("Class").size).toBe(4);
-    });
-
-    it("should contain a class EntityClass", () => {
-        expect(fmxRep._getFamixClass("EntityClass")).toBeTruthy();
-    });
-
-    it("should contain a class class2", () => {
-        expect(fmxRep._getFamixClass("class2")).toBeTruthy();
-    });
-
-    it("should contain a class clsInNsp3", () => {
-        expect(fmxRep._getFamixClass("clsInNsp3")).toBeTruthy();
-    });
-
-    it("should contain a class clsOutNsp", () => {
-        expect(fmxRep._getFamixClass("clsOutNsp")).toBeTruthy();
-    });
-});