-- Added many unit tests for the C parser. Almost complete now

-- Refactored project structure to allow for more overview once we add more languages.
-- Renamed a lot of types in the CParser to be more explicit.
-- Made configuration injectable into the classes that need them. This allows to unit test configuration variables.
-- Added 2 new config params that allows to customize what gets returned for a bool return type.
-- Small changes to the logic to make it more concise.

9 files changed, 310 insertions, 104 deletions

diff --git a/src/test/Attributes.test.ts b/src/test/CTests/Attributes.test.ts
index 680694a..b4cffbb 100644
--- a/src/test/Attributes.test.ts
+++ b/src/test/CTests/Attributes.test.ts
@@ -9,7 +9,7 @@ import * as assert from "assert";
 // You can import and use all API from the 'vscode' module
 // as well as import your extension to test it
 import * as vscode from "vscode";
-import TestSetup from "./tools/TestSetup";
+import TestSetup from "./TestSetup";
 
 // Defines a Mocha test suite to group tests of similar kind together
 suite("Attributes Tests", () => {
@@ -46,4 +46,17 @@ suite("Attributes Tests", () => {
         const result = testSetup.SetLine("struct [[nodiscard]] alignas(8) Matrix {").GetResult();
         assert.equal("/**\n * @brief \n * \n */", result);
     });
+
+    test("Noexcept on function", () => {
+        let result = testSetup.SetLine("constexpr int foo(int a, double& b) noexcept(true);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param a \n * @param b \n * @return constexpr int \n */", result);
+
+        result = testSetup.SetLine("constexpr int foo(int a, double& b) noexcept;").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param a \n * @param b \n * @return constexpr int \n */", result);
+    });
+
+    test("Throw on function", () => {
+        const result = testSetup.SetLine("constexpr int foo(int a, double& b) throw(std::except);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param a \n * @param b \n * @return constexpr int \n */", result);
+    });
 });
diff --git a/src/test/FunctionPointer.test.ts b/src/test/CTests/FunctionPointer.test.ts
index dd1ead0..b5cd3bb 100644
--- a/src/test/FunctionPointer.test.ts
+++ b/src/test/CTests/FunctionPointer.test.ts
@@ -9,30 +9,30 @@ import * as assert from "assert";
 // You can import and use all API from the 'vscode' module
 // as well as import your extension to test it
 import * as vscode from "vscode";
-import TestSetup from "./tools/TestSetup";
+import TestSetup from "./TestSetup";
 
 // Defines a Mocha test suite to group tests of similar kind together
 suite("Function pointer Tests", () => {
     const testSetup: TestSetup = new TestSetup("void foo();");
 
     // Tests
-    test("function pointer return", () => {
+    test("Function pointer return", () => {
         const result = testSetup.SetLine("int (*idputs(int a, int b))(char *);").GetResult();
         assert.equal("/**\n * @brief \n * \n * @param a \n * @param b \n * @return int(*)(char*) \n */", result);
     });
 
-    test("nested function pointer return", () => {
+    test("Nested function pointer return", () => {
         const result = testSetup.SetLine("int (*(*(*foo(int a, int b))(int))(double))(float);").GetResult();
         assert.equal("/**\n * @brief \n * \n * @param a \n * @param b \n"
             + " * @return int(*(*(*)(int))(double))(float) \n */", result);
     });
 
-    test("function pointer parameter", () => {
+    test("Function pointer parameter", () => {
         const result = testSetup.SetLine("int foo(int (*puts)(const char *));").GetResult();
         assert.equal("/**\n * @brief \n * \n * @param puts \n * @return int \n */", result);
     });
 
-    test("struct function pointer return with struct FP parameters and keywords", () => {
+    test("Struct function pointer return with struct FP parameters and keywords", () => {
         const result = testSetup.SetLine("const struct foo (*idputs(int (*puts)(const char *), const"
             + " struct test(*str)(int *, const struct test(*str2))))(const char *);").GetResult();
 
diff --git a/src/test/CTests/Operators.test.ts b/src/test/CTests/Operators.test.ts
new file mode 100644
index 0000000..dd2aa5b
--- /dev/null
+++ b/src/test/CTests/Operators.test.ts
@@ -0,0 +1,256 @@
+//
+// Note: This example test is leveraging the Mocha test framework.
+// Please refer to their documentation on https://mochajs.org/ for help.
+//
+
+// The module 'assert' provides assertion methods from node
+import * as assert from "assert";
+
+// You can import and use all API from the 'vscode' module
+// as well as import your extension to test it
+import * as vscode from "vscode";
+import TestSetup from "./TestSetup";
+
+// Defines a Mocha test suite to group tests of similar kind together
+suite("Operators Tests", () => {
+    const testSetup: TestSetup = new TestSetup("void foo();");
+
+    // Tests
+    test("+ operator", () => {
+        const result = testSetup.SetLine("T operator +(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("- operator", () => {
+        const result = testSetup.SetLine("T operator- (const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("* operator", () => {
+        const result = testSetup.SetLine("T operator*(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("/ operator", () => {
+        const result = testSetup.SetLine("T operator/(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("% operator", () => {
+        const result = testSetup.SetLine("T operator%(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("^ operator", () => {
+        const result = testSetup.SetLine("T operator^(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("& operator", () => {
+        const result = testSetup.SetLine("T operator&(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("| operator", () => {
+        const result = testSetup.SetLine("T operator|(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("~ operator", () => {
+        const result = testSetup.SetLine("T operator~(const T& t);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param t \n * @return T \n */", result);
+    });
+
+    test("<< operator", () => {
+        const result = testSetup.SetLine("T operator<<(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test(">> operator", () => {
+        const result = testSetup.SetLine("T operator>>(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("! operator", () => {
+        const result = testSetup.SetLine("bool operator!(const T& t);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param t \n * @return true \n * @return false \n */", result);
+    });
+
+    test("&& operator", () => {
+        const result = testSetup.SetLine("bool operator&&(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return true \n"
+            + " * @return false \n */", result);
+    });
+
+    test("|| operator", () => {
+        const result = testSetup.SetLine("bool operator||(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return true \n"
+            + " * @return false \n */", result);
+    });
+
+    test("!= operator", () => {
+        const result = testSetup.SetLine("bool operator!=(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return true \n"
+            + " * @return false \n */", result);
+    });
+
+    test("== operator", () => {
+        const result = testSetup.SetLine("bool operator==(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return true \n"
+            + " * @return false \n */", result);
+    });
+
+    test("<= operator", () => {
+        const result = testSetup.SetLine("bool operator<=(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return true \n"
+            + " * @return false \n */", result);
+    });
+
+    test(">= operator", () => {
+        const result = testSetup.SetLine("bool operator>=(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return true \n"
+            + " * @return false \n */", result);
+    });
+
+    test("< operator", () => {
+        const result = testSetup.SetLine("bool operator<(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return true \n"
+            + " * @return false \n */", result);
+    });
+
+    test("> operator", () => {
+        const result = testSetup.SetLine("bool operator>(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return true \n"
+            + " * @return false \n */", result);
+    });
+
+    test("= operator", () => {
+        const result = testSetup.SetLine("T& operator=(const T& t);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result);
+    });
+
+    test("+= operator", () => {
+        const result = testSetup.SetLine("T& operator+=(const T& t);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result);
+    });
+
+    test("-= operator", () => {
+        const result = testSetup.SetLine("T& operator-=(const T& t);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result);
+    });
+
+    test("*= operator", () => {
+        const result = testSetup.SetLine("T& operator*=(const T& t);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result);
+    });
+
+    test("/= operator", () => {
+        const result = testSetup.SetLine("T& operator/=(const T& t);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result);
+    });
+
+    test("%= operator", () => {
+        const result = testSetup.SetLine("T& operator%=(const T& t);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result);
+    });
+
+    test("^= operator", () => {
+        const result = testSetup.SetLine("T& operator^=(const T& t);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result);
+    });
+
+    test("&= operator", () => {
+        const result = testSetup.SetLine("T& operator&=(const T& t);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result);
+    });
+
+    test("|= operator", () => {
+        const result = testSetup.SetLine("T& operator|=(const T& t);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result);
+    });
+
+    test(">>= operator", () => {
+        const result = testSetup.SetLine("T& operator>>=(const T& t);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result);
+    });
+
+    test("<<= operator", () => {
+        const result = testSetup.SetLine("T& operator<<=(const T& t);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param t \n * @return T& \n */", result);
+    });
+
+    test("prefix ++ operator", () => {
+        const result = testSetup.SetLine("T& operator++();").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @return T& \n */", result);
+    });
+
+    test("prefix -- operator", () => {
+        const result = testSetup.SetLine("T& operator--();").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @return T& \n */", result);
+    });
+
+    test("postfix ++ operator", () => {
+        const result = testSetup.SetLine("T operator++(int);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @return T \n */", result);
+    });
+
+    test("postfix -- operator", () => {
+        const result = testSetup.SetLine("T operator--(int);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @return T \n */", result);
+    });
+
+    test(", operator", () => {
+        const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("->* operator", () => {
+        const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("-> operator", () => {
+        const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("[] operator", () => {
+        const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("() operator", () => {
+        const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("new operator", () => {
+        const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("new[] operator", () => {
+        const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("delete operator", () => {
+        const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("delete[] operator", () => {
+        const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("user literal operator", () => {
+        const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+
+    test("conversion operator", () => {
+        const result = testSetup.SetLine("T operator+(const T& lhs, const T2& rhs);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
+    });
+});
diff --git a/src/test/ReturnTypes.test.ts b/src/test/CTests/ReturnTypes.test.ts
index f38fb1f..7d823d1 100644
--- a/src/test/ReturnTypes.test.ts
+++ b/src/test/CTests/ReturnTypes.test.ts
@@ -9,7 +9,7 @@ import * as assert from "assert";
 // You can import and use all API from the 'vscode' module
 // as well as import your extension to test it
 import * as vscode from "vscode";
-import TestSetup from "./tools/TestSetup";
+import TestSetup from "./TestSetup";
 
 // Defines a Mocha test suite to group tests of similar kind together
 suite("Return type Tests", () => {
@@ -17,12 +17,12 @@ suite("Return type Tests", () => {
     const testSetup: TestSetup = new TestSetup("void foo();");
 
     // Tests
-    test("void return", () => {
+    test("Void return", () => {
         const result = testSetup.SetLine("void foo();").GetResult();
         assert.equal("/**\n * @brief \n * \n */", result);
     });
 
-    test("void pointer return", () => {
+    test("Void pointer return", () => {
         const result = testSetup.SetLine("void* foo();").GetResult();
         assert.equal("/**\n * @brief \n * \n * @return void* \n */", result);
     });
@@ -32,22 +32,22 @@ suite("Return type Tests", () => {
         assert.equal("/**\n * @brief \n * \n * @return int& \n */", result);
     });
 
-    test("simple type return", () => {
+    test("Simple type return", () => {
         const result = testSetup.SetLine("int foo();").GetResult();
         assert.equal("/**\n * @brief \n * \n * @return int \n */", result);
     });
 
-    test("bool return type", () => {
+    test("Bool return type", () => {
         const result = testSetup.SetLine("bool foo();").GetResult();
         assert.equal("/**\n * @brief \n * \n * @return true \n * @return false \n */", result);
     });
 
-    test("pointer return type", () => {
+    test("Pointer return type", () => {
         const result = testSetup.SetLine("int* foo();").GetResult();
         assert.equal("/**\n * @brief \n * \n * @return int* \n */", result);
     });
 
-    test("bool pointer return type", () => {
+    test("Bool pointer return type", () => {
         const result = testSetup.SetLine("bool* foo();").GetResult();
         assert.equal("/**\n * @brief \n * \n * @return true \n * @return false \n * @return null \n */", result);
     });
diff --git a/src/test/Templates.test.ts b/src/test/CTests/Templates.test.ts
index d4c0fe6..2fbd9b1 100644
--- a/src/test/Templates.test.ts
+++ b/src/test/CTests/Templates.test.ts
@@ -9,14 +9,14 @@ import * as assert from "assert";
 // You can import and use all API from the 'vscode' module
 // as well as import your extension to test it
 import * as vscode from "vscode";
-import TestSetup from "./tools/TestSetup";
+import TestSetup from "./TestSetup";
 
 // Defines a Mocha test suite to group tests of similar kind together
 suite("Template tests", () => {
     const testSetup: TestSetup = new TestSetup("void foo();");
 
     // Tests
-    test("template class", () => {
+    test("Template class", () => {
         const result = testSetup.SetLine("template<typename T, std::size_t M, std::size_t N,"
             + "typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type>"
             + "class matrix {").GetResult();
@@ -24,21 +24,28 @@ suite("Template tests", () => {
             + "@tparam std::enable_if<std::is_arithmetic<T>::value, T>::type \n */", result);
     });
 
-    test("template function", () => {
+    test("Template function", () => {
         const result = testSetup.SetLine("template<typename T, typename S>\nT f(T a, S b);").GetResult();
         assert.equal("/**\n * @brief \n * \n * @tparam T \n * @tparam S \n * @param a \n * "
             + "@param b \n * @return T \n */", result);
     });
 
-    test("double template", () => {
+    test("Double template", () => {
         const result = testSetup.SetLine("template<typename T>\ntemplate<typename S>\nT f(T a, S b);").GetResult();
         assert.equal("/**\n * @brief \n * \n * @tparam T \n * @tparam S \n * @param a \n * "
             + "@param b \n * @return T \n */", result);
     });
 
-    test("template struct", () => {
+    test("Template struct", () => {
         const result = testSetup.SetLine("template<typename T, std::size_t m, std::size_t n>\n"
             + "struct myStruct {").GetResult();
         assert.equal("/**\n * @brief \n * \n * @tparam T \n * @tparam m \n * @tparam n \n */", result);
     });
+
+    test("Variadic template", () => {
+        const result = testSetup.SetLine("template<typename T, typename... Args>"
+            + "\nT adder(T first, Args... args);").GetResult();
+        assert.equal("/**\n * @brief \n * \n * @tparam T \n * @tparam Args \n *"
+            + " @param first \n * @param args \n * @return T \n */", result);
+    });
 });
diff --git a/src/test/tools/TestSetup.ts b/src/test/CTests/TestSetup.ts
index 1270616..1eb9c86 100644
--- a/src/test/tools/TestSetup.ts
+++ b/src/test/CTests/TestSetup.ts
@@ -1,15 +1,19 @@
 import * as vscode from "vscode";
-import CodeParser from "../../CodeParser/CodeParser";
-import CParser from "../../CodeParser/CParser/CParser";
-import { IDocGen } from "../../DocGen/DocGen";
+
+import CodeParser from "../../Common/ICodeParser";
+import { IDocGen } from "../../Common/IDocGen";
+import { Config } from "../../Config";
 import * as myExtension from "../../extension";
-import MockDocument from "./MockDocument";
-import MockEditor from "./MockEditor";
-import MockLine from "./MockLine";
-import MockPosition from "./MockPosition";
-import MockSelection from "./MockSelection";
+import CParser from "../../Lang/C/CParser";
+import MockDocument from "../tools/MockDocument";
+import MockEditor from "../tools/MockEditor";
+import MockLine from "../tools/MockLine";
+import MockPosition from "../tools/MockPosition";
+import MockSelection from "../tools/MockSelection";
 
 export default class TestSetup {
+    public cfg: Config;
+
     private editor: MockEditor;
 
     constructor(method: string) {
@@ -17,6 +21,8 @@ export default class TestSetup {
     }
 
     public SetLine(method: string): TestSetup {
+        this.cfg = new Config();
+
         let position: MockPosition;
         position = new MockPosition(0, 0);
 
@@ -36,7 +42,7 @@ export default class TestSetup {
 
     public GetResult(): string {
         let parser: CodeParser;
-        parser = new CParser();
+        parser = new CParser(new Config());
 
         const gen: IDocGen = parser.Parse(this.editor);
         gen.GenerateDoc(new vscode.Range(new vscode.Position(0, 0), new vscode.Position(0, 0)));
diff --git a/src/test/TrailingReturns.test.ts b/src/test/CTests/TrailingReturns.test.ts
index 6c182f9..8ad5799 100644
--- a/src/test/TrailingReturns.test.ts
+++ b/src/test/CTests/TrailingReturns.test.ts
@@ -9,7 +9,7 @@ import * as assert from "assert";
 // You can import and use all API from the 'vscode' module
 // as well as import your extension to test it
 import * as vscode from "vscode";
-import TestSetup from "./tools/TestSetup";
+import TestSetup from "./TestSetup";
 
 // Defines a Mocha test suite to group tests of similar kind together
 suite("Trailing returns tests", () => {
diff --git a/src/test/Operators.test.ts b/src/test/Operators.test.ts
deleted file mode 100644
index 86c04b2..0000000
--- a/src/test/Operators.test.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// Note: This example test is leveraging the Mocha test framework.
-// Please refer to their documentation on https://mochajs.org/ for help.
-//
-
-// The module 'assert' provides assertion methods from node
-import * as assert from "assert";
-
-// You can import and use all API from the 'vscode' module
-// as well as import your extension to test it
-import * as vscode from "vscode";
-import TestSetup from "./tools/TestSetup";
-
-// Defines a Mocha test suite to group tests of similar kind together
-suite("Operators Tests", () => {
-    const testSetup: TestSetup = new TestSetup("void foo();");
-
-    // Tests
-    test("", () => {
-        const result = testSetup.SetLine("").GetResult();
-        assert.equal("", result);
-    });
-
-    test("", () => {
-        const result = testSetup.SetLine("").GetResult();
-        assert.equal("", result);
-    });
-
-    test("", () => {
-        const result = testSetup.SetLine("").GetResult();
-        assert.equal("", result);
-    });
-
-    test("", () => {
-        const result = testSetup.SetLine("").GetResult();
-        assert.equal("", result);
-    });
-});
diff --git a/src/test/Variadic.test.ts b/src/test/Variadic.test.ts
deleted file mode 100644
index 2ded458..0000000
--- a/src/test/Variadic.test.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// Note: This example test is leveraging the Mocha test framework.
-// Please refer to their documentation on https://mochajs.org/ for help.
-//
-
-// The module 'assert' provides assertion methods from node
-import * as assert from "assert";
-
-// You can import and use all API from the 'vscode' module
-// as well as import your extension to test it
-import * as vscode from "vscode";
-import TestSetup from "./tools/TestSetup";
-
-// Defines a Mocha test suite to group tests of similar kind together
-suite("Variadic tests", () => {
-    const testSetup: TestSetup = new TestSetup("void foo();");
-
-    // Tests
-    test("", () => {
-        const result = testSetup.SetLine("").GetResult();
-        assert.equal("", result);
-    });
-
-    test("", () => {
-        const result = testSetup.SetLine("").GetResult();
-        assert.equal("", result);
-    });
-
-    test("", () => {
-        const result = testSetup.SetLine("").GetResult();
-        assert.equal("", result);
-    });
-
-    test("", () => {
-        const result = testSetup.SetLine("").GetResult();
-        assert.equal("", result);
-    });
-});