Some random tests + cleanup of tshelper

Perryvw · Perryvw · commit 9eab65090bce · 2018-03-26T21:52:30.000+02:00
diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -27,7 +27,7 @@ export class TSHelper {
 
     // Breaks down a mask into all flag names.
     public static enumNames(mask, haystack) {
-        const result = [mask];
+        const result = [];
         for (const name in haystack) {
             if ((mask & haystack[name]) !== 0 && mask >= haystack[name]) {
                 result.push(name);
@@ -110,21 +110,6 @@ export class TSHelper {
         return false;
     }
 
-    // Depth-First-Search up the inheritance tree for the name of the symbol containing the member
-    public static findMemberHolder(type: ts.Type, memberName: ts.__String, typeChecker: ts.TypeChecker): string {
-        if (type.symbol.members.has(memberName) || (type.symbol.exports && type.symbol.exports.has(memberName))) {
-            while (this.isExtensionClass(type, typeChecker)) {
-                type = typeChecker.getBaseTypes(type as ts.InterfaceType)[0];
-            }
-            return type.symbol.name;
-        } else {
-            for (const parent of typeChecker.getBaseTypes(type as ts.InterfaceType)) {
-                const parentMember = this.findMemberHolder(parent, memberName, typeChecker);
-                if (parentMember) { return parentMember; }
-            }
-        }
-    }
-
     // Search up until finding a node satisfying the callback
     public static findFirstNodeAbove<T extends ts.Node>(node: ts.Node, callback: (n: ts.Node) => n is T): T {
         let current = node;
diff --git a/test/unit/loops.spec.ts b/test/unit/loops.spec.ts
@@ -98,6 +98,9 @@ export class LuaLoopTests {
     }
 
     @TestCase([0, 1, 2, 3], [1, 2, 3, 4], "let i = 0; i < arrTest.length; i++")
+    @TestCase([0, 1, 2, 3], [1, 2, 3, 4], "let i = 0; i <= arrTest.length - 1; i++")
+    @TestCase([0, 1, 2, 3], [1, 2, 3, 4], "let i = 0; arrTest.length > i; i++")
+    @TestCase([0, 1, 2, 3], [1, 2, 3, 4], "let i = 0; arrTest.length - 1 >= i; i++")
     @TestCase([0, 1, 2, 3], [1, 1, 3, 3], "let i = 0; i < arrTest.length; i += 2")
     @TestCase([0, 1, 2, 3], [1, 2, 3, 4], "let i = arrTest.length - 1; i <= 0; i--")
     @TestCase([0, 1, 2, 3], [0, 2, 2, 4], "let i = arrTest.length - 1; i <= 0; i -= 2")
@@ -135,18 +138,26 @@ export class LuaLoopTests {
         }).toThrowError(Error, "Unsupported for-loop increment step: BinaryExpression")
     }
 
+    @TestCase("let i = 0; i + 3; i++")
+    @TestCase("let i = 0; 3 + i; i++")
+    @TestCase("let i = 0; i - 3; i++")
+    @TestCase("let i = 0; i * 3; i++")
+    @TestCase("let i = 0; i / 3; i++")
+    @TestCase("let i = 0; i &= 3; i++")
+    @TestCase("let i = 0; i < 3; !i")
+    @TestCase("let i = 0; i < 3; i as string")
     @Test("forconditionThrow")
-    public forconditionThrow(inp: number[], expected: number[], header: string) {
+    public forconditionThrow(header: string) {
         // Transpile & Assert
         Expect(() => {
             let lua = util.transpileString(
-                `for (let i = arrTest.length - 1; i; i-- {
+                `for (${header}) {
                 }`
             );
 
             // Execute
             let result = util.executeLua(lua);
-        }).toThrowError(Error, "Unsupported for-loop condition type: Identifier")
+        }).toThrow();
     }
 
     @TestCase({ ['test1']: 0, ['test2']: 1, ['test3']: 2 }, { ['test1']: 1, ['test2']: 2, ['test3']: 3 })
diff --git a/test/unit/tshelper.spec.ts b/test/unit/tshelper.spec.ts
@@ -0,0 +1,39 @@
+import * as ts from "typescript";
+
+import { Expect, FocusTest, IgnoreTest, Test, TestCase } from "alsatian";
+import { TSHelper as tsEx } from "../../src/TSHelper";
+
+enum TestEnum {
+    testA = 1,
+    testB = 2,
+    testC = 4,
+}
+
+export class TSHelperTests {
+
+    @TestCase(TestEnum.testA, "testA")
+    @TestCase(-1, "unknown")
+    @TestCase(TestEnum.testA | TestEnum.testB, "unknown")
+    @Test("EnumName")
+    public testEnumName(inp, expected) {
+        const result = tsEx.enumName(inp, TestEnum);
+
+        Expect(result).toEqual(expected);
+    }
+
+    @TestCase(TestEnum.testA, ["testA"])
+    @TestCase(-1, [])
+    @TestCase(TestEnum.testA | TestEnum.testC, ["testA", "testC"])
+    @TestCase(TestEnum.testA | TestEnum.testB | TestEnum.testC, ["testA", "testB", "testC"])
+    @Test("EnumNames")
+    public testEnumNames(inp, expected) {
+        const result = tsEx.enumNames(inp, TestEnum);
+
+        Expect(result).toEqual(expected);
+    }
+
+    @Test("IsFileModuleNull")
+    public isFileModuleNull() {
+        Expect(tsEx.isFileModule(null)).toEqual(false);
+    }
+}
