Replaced assert.equal() calls by assert.strictEqual() calls (#188)

Due to message: deprecated since v9.9.0 - use strictEqual() instead.

12 files changed, 254 insertions, 254 deletions

diff --git a/src/test/CppTests/Attributes.test.ts b/src/test/CppTests/Attributes.test.ts
index a6641e1..a8316fa 100644
--- a/src/test/CppTests/Attributes.test.ts
+++ b/src/test/CppTests/Attributes.test.ts
@@ -18,50 +18,50 @@ suite("C++ - Attributes Tests", () => {
     // Tests
     test("Attributes on parameter", () => {
         const result = testSetup.SetLine("int foo([[maybe_unused]] int a, [[maybe_unused]]double& b);").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @param a \n * @param b \n * @return int \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n * @param a \n * @param b \n * @return int \n */", result);
     });
 
     test("Attributes on function", () => {
         const result = testSetup.SetLine("[[nodiscard]] int foo(int a, double& b);").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @param a \n * @param b \n * @return int \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n * @param a \n * @param b \n * @return int \n */", result);
     });
 
     test("Multiple attributes on parameter", () => {
         const result = testSetup.SetLine("int foo([[maybe_unused]] [[carries_dependency]]"
             + " int a, double& b);").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @param a \n * @param b \n * @return int \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n * @param a \n * @param b \n * @return int \n */", result);
     });
 
     test("Multiple attributes on function", () => {
         const result = testSetup.SetLine("[[nodiscard]][[deprecated(\"old\")]] int foo(int a, double& b);").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @param a \n * @param b \n * @return int \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n * @param a \n * @param b \n * @return int \n */", result);
     });
 
     test("Specifier and attribute on class", () => {
         const result = testSetup.SetLine("class [[nodiscard]] alignas(8) Matrix {").GetResult();
-        assert.equal("/**\n * @brief \n * \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n */", result);
     });
 
     test("Specifier and attribute on struct", () => {
         const result = testSetup.SetLine("struct [[nodiscard]] alignas(8) Matrix {").GetResult();
-        assert.equal("/**\n * @brief \n * \n */", result);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\n * @brief \n * \n * @param a \n * @param b \n * @return constexpr int \n */", result);
     });
 
     test("Newline in function", () => {
         const result = testSetup.SetLines(["static void ResetActionState( BOOL sendNAK )", "{"]).GetResult();
-        assert.equal("/**\n * @brief \n * \n * @param sendNAK \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n * @param sendNAK \n */", result);
     });
 });
diff --git a/src/test/CppTests/Con-AndDestructor.test.ts b/src/test/CppTests/Con-AndDestructor.test.ts
index ba60501..44cb5a6 100644
--- a/src/test/CppTests/Con-AndDestructor.test.ts
+++ b/src/test/CppTests/Con-AndDestructor.test.ts
@@ -20,46 +20,46 @@ suite("C++ - Con- and Destructor Tests", () => {
     // Tests
     test("Normal Constructor", () => {
         const result = testSetup.SetLine("Foo(int a);").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @param a \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n * @param a \n */", result);
     });
 
     test("Constructor with initializer list", () => {
         const result = testSetup.SetLine("Foo(int a) : m_a(a) {").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @param a \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n * @param a \n */", result);
     });
 
     test("Explicit Constructor", () => {
         const result = testSetup.SetLine("explicit Foo(int a);").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @param a \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n * @param a \n */", result);
     });
 
     test("Deleted Constructor", () => {
         const result = testSetup.SetLine("Foo(int a) = delete;").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @param a \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n * @param a \n */", result);
     });
 
     test("Default Constructor", () => {
         const result = testSetup.SetLine("Foo() = default;").GetResult();
-        assert.equal("/**\n * @brief \n * \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n */", result);
     });
 
     test("Destructor", () => {
         const result = testSetup.SetLine("~Foo();").GetResult();
-        assert.equal("/**\n * @brief \n * \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n */", result);
     });
 
     test("Virtual Destructor", () => {
         const result = testSetup.SetLine("virtual ~Foo();").GetResult();
-        assert.equal("/**\n * @brief \n * \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n */", result);
     });
 
     test("Deleted Destructor", () => {
         const result = testSetup.SetLine("virtual ~Foo() = 0;").GetResult();
-        assert.equal("/**\n * @brief \n * \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n */", result);
     });
 
     test("Default Destructor", () => {
         const result = testSetup.SetLine("~Foo() = default;").GetResult();
-        assert.equal("/**\n * @brief \n * \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n */", result);
     });
 });
diff --git a/src/test/CppTests/Config.test.ts b/src/test/CppTests/Config.test.ts
index d479d2d..aae09d4 100644
--- a/src/test/CppTests/Config.test.ts
+++ b/src/test/CppTests/Config.test.ts
@@ -21,7 +21,7 @@ suite("C++ - Configuration Tests", () => {
     test("Default config", () => {
         testSetup.cfg = new Config();
         const result = testSetup.SetLine("template<typename T> bool foo(T a);").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @tparam T \n * @param a \n * "
+        assert.strictEqual("/**\n * @brief \n * \n * @tparam T \n * @param a \n * "
             + "@return true \n * @return false \n */", result);
     });
 
@@ -29,7 +29,7 @@ suite("C++ - Configuration Tests", () => {
         testSetup.cfg = new Config();
         testSetup.cfg.Generic.order = ["brief", "param", "tparam", "return"];
         const result = testSetup.SetLine("template<typename T> bool foo(T a);").GetResult();
-        assert.equal("/**\n * @brief \n * @param a \n * @tparam T \n * "
+        assert.strictEqual("/**\n * @brief \n * @param a \n * @tparam T \n * "
             + "@return true \n * @return false \n */", result);
     });
 
@@ -37,7 +37,7 @@ suite("C++ - Configuration Tests", () => {
         testSetup.cfg = new Config();
         testSetup.cfg.Generic.order = ["breif"];
         const result = testSetup.SetLine("template<typename T> bool foo(T a);").GetResult();
-        assert.equal("/**\n */", result);
+        assert.strictEqual("/**\n */", result);
     });
 
     test("Modified template", () => {
@@ -52,7 +52,7 @@ suite("C++ - Configuration Tests", () => {
         testSetup.cfg.Generic.returnTemplate = "\\return {type} ";
 
         const result = testSetup.SetLine("template<typename T> bool foo(T a);").GetResult();
-        assert.equal("/// \\brief \n/// \n/// \\tparam T \n/// \\param a \n"
+        assert.strictEqual("/// \\brief \n/// \n/// \\tparam T \n/// \\param a \n"
             + "/// \\return true \n/// \\return false ", result);
 
     });
@@ -61,7 +61,7 @@ suite("C++ - Configuration Tests", () => {
         testSetup.cfg = new Config();
         testSetup.cfg.Generic.boolReturnsTrueFalse = false;
         const result = testSetup.SetLine("template<typename T> bool foo(T a);").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @tparam T \n * @param a \n"
+        assert.strictEqual("/**\n * @brief \n * \n * @tparam T \n * @param a \n"
             + " * @return bool \n */", result);
     });
 
@@ -70,7 +70,7 @@ suite("C++ - Configuration Tests", () => {
         testSetup.cfg.Generic.includeTypeAtReturn = false;
 
         const result = testSetup.SetLine("template<typename T> bool foo(T a);").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @tparam T \n * @param a \n"
+        assert.strictEqual("/**\n * @brief \n * \n * @tparam T \n * @param a \n"
             + " * @return  \n */", result);
     });
 
@@ -80,18 +80,18 @@ suite("C++ - Configuration Tests", () => {
 
         const result = testSetup.SetLine("template<typename T> bool foo(T a);").GetResult();
         testSetup.cfg.Generic.order = ["brief", "empty", "tparam", "param", "return"]; // reset to default
-        assert.equal("/**\n * @brief \n * @tparam T \n * \n * @param a \n * \n"
+        assert.strictEqual("/**\n * @brief \n * @tparam T \n * \n * @param a \n * \n"
             + " * @return true \n * @return false \n */", result);
     });
 
     test("Indentation test", () => {
         testSetup.cfg = new Config();
         let result = testSetup.SetLine("\ttemplate<typename T> bool foo(T a);").GetResult();
-        assert.equal("/**\n\t * @brief \n\t * \n\t * @tparam T \n\t * @param a \n\t * "
+        assert.strictEqual("/**\n\t * @brief \n\t * \n\t * @tparam T \n\t * @param a \n\t * "
             + "@return true \n\t * @return false \n\t */", result);
 
         result = testSetup.SetLine("          template<typename T> bool foo(T a);").GetResult();
-        assert.equal("/**\n           * @brief \n           * \n           * @tparam T "
+        assert.strictEqual("/**\n           * @brief \n           * \n           * @tparam T "
             + "\n           * @param a \n           * "
             + "@return true \n           * @return false \n           */", result);
     });
@@ -100,12 +100,12 @@ suite("C++ - Configuration Tests", () => {
         testSetup.cfg = new Config();
         testSetup.cfg.Generic.linesToGet = 2;
         const positiveResult = testSetup.SetLines(["template<typename T> bool \n", "foo(T a);"]).GetResult();
-        assert.equal("/**\n * @brief \n * \n * @tparam T \n * @param a \n * "
+        assert.strictEqual("/**\n * @brief \n * \n * @tparam T \n * @param a \n * "
             + "@return true \n * @return false \n */", positiveResult);
         testSetup.cfg.Generic.linesToGet = 0;
         testSetup.firstLine = 1;
         const negativeResult = testSetup.SetLines(["template<typename T> bool \n", "foo(T a);"]).GetResult();
-        assert.equal("/**\n * @brief \n * \n */", negativeResult);
+        assert.strictEqual("/**\n * @brief \n * \n */", negativeResult);
     });
 
     test("File description order test", () => {
@@ -113,50 +113,50 @@ suite("C++ - Configuration Tests", () => {
         testSetup.firstLine = 0;
         testSetup.cfg.File.fileOrder = ["brief", "author", "date", "file"];
         const result = testSetup.SetLine("").GetResult();
-        assert.equal("/**\n * @brief \n * @author your name (you@domain.com)\n" +
+        assert.strictEqual("/**\n * @brief \n * @author your name (you@domain.com)\n" +
             " * @date " + moment().format("YYYY-MM-DD") + "\n * @file MockDocument.h\n */", result);
     });
 
     test("Custom smart text Ctor", () => {
         testSetup.cfg.Cpp.ctorText = "Test {name}";
         const result = testSetup.SetLine("Foo();").GetResult();
-        assert.equal("/**\n * @brief Test Foo\n * \n */", result);
+        assert.strictEqual("/**\n * @brief Test Foo\n * \n */", result);
     });
 
     test("Custom smart text Dtor", () => {
         testSetup.cfg.Cpp.dtorText = "Test {name}";
         const result = testSetup.SetLine("~Foo();").GetResult();
-        assert.equal("/**\n * @brief Test Foo\n * \n */", result);
+        assert.strictEqual("/**\n * @brief Test Foo\n * \n */", result);
     });
 
     test("Custom smart text getter", () => {
         testSetup.cfg.C.getterText = "Test {name}";
         const result = testSetup.SetLine("int getFoo();").GetResult();
-        assert.equal("/**\n * @brief Test Foo\n * \n * @return int \n */", result);
+        assert.strictEqual("/**\n * @brief Test Foo\n * \n * @return int \n */", result);
     });
 
     test("Custom smart text setter", () => {
         testSetup.cfg.C.setterText = "Test {name}";
         const result = testSetup.SetLine("void setFoo(int foo);").GetResult();
-        assert.equal("/**\n * @brief Test Foo\n * \n * @param foo \n */", result);
+        assert.strictEqual("/**\n * @brief Test Foo\n * \n * @param foo \n */", result);
     });
 
     test("Custom smart text factory method", () => {
         testSetup.cfg.C.factoryMethodText = "Test {name}";
         const result = testSetup.SetLine("int createFoo();").GetResult();
-        assert.equal("/**\n * @brief Test Foo\n * \n * @return int \n */", result);
+        assert.strictEqual("/**\n * @brief Test Foo\n * \n * @return int \n */", result);
     });
 
     test("Don't split casing for smart text", () => {
         testSetup.cfg.C.factoryMethodText = "Test {name}";
         testSetup.cfg.Generic.splitCasingSmartText = false;
         const result = testSetup.SetLine("int createFooObject();").GetResult();
-        assert.equal("/**\n * @brief Test FooObject\n * \n * @return int \n */", result);
+        assert.strictEqual("/**\n * @brief Test FooObject\n * \n * @return int \n */", result);
     });
 
     test("Remove inserted '*/' from line", () => {
         const result = testSetup.SetLines(["*/", "int foo();"]).GetResult();
-        assert.equal("/**\n * @brief \n * \n * @return int \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n * @return int \n */", result);
     });
 
     test("Single alignment", () => {
@@ -167,7 +167,7 @@ suite("C++ - Configuration Tests", () => {
 
         const result = testSetup.SetLines(["template<typename T>", "int foo(std::string bar, T foobar);"]).GetResult();
         // tslint:disable-next-line:max-line-length
-        assert.equal("/**\n * @brief    Brief\n * \n * @tparam   T\n * @param    bar\n * @param    foobar\n * @return   int\n */", result);
+        assert.strictEqual("/**\n * @brief    Brief\n * \n * @tparam   T\n * @param    bar\n * @param    foobar\n * @return   int\n */", result);
     });
 
     test("Multi alignment", () => {
@@ -198,7 +198,7 @@ suite("C++ - Configuration Tests", () => {
         testSetup.cfg.Generic.returnTemplate = "<returns>\n</returns>";
         const result = testSetup.SetLine("    int foo(bool a);").GetResult();
         // tslint:disable:no-trailing-whitespace
-        assert.equal(
+        assert.strictEqual(
             result, `/// <summary>
     /// 
     /// </summary>
@@ -216,7 +216,7 @@ suite("C++ - Configuration Tests", () => {
         testSetup.cfg.Generic.filteredKeywords = ["MOCKABLE"];
         // tslint:disable-next-line:max-line-length
         const result = testSetup.SetLine("MOCKABLE void processNetworkStatusReset( const common_n::NetworkCommands_s *networkstatus );").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @param networkstatus \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n * @param networkstatus \n */", result);
     });
 
     test("Custom tag", () => {
@@ -224,7 +224,7 @@ suite("C++ - Configuration Tests", () => {
         testSetup.cfg.Generic.order = ["custom"];
         testSetup.cfg.Generic.customTags = ["@note"];
         const result = testSetup.SetLine("void foo();").GetResult();
-        assert.equal("/**\n * @note\n */", result);
+        assert.strictEqual("/**\n * @note\n */", result);
     });
 
     test("Env variable", () => {
@@ -234,17 +234,17 @@ suite("C++ - Configuration Tests", () => {
             testSetup.cfg.Generic.customTags = ["@author ${env:USERNAME}"];
             const res = testSetup.SetLine("void foo();").GetResult();
             // USERNAME env var is different for everybody
-            assert.notEqual("/**\n * @author USERNAME\n */", res);
+            assert.notStrictEqual("/**\n * @author USERNAME\n */", res);
         } else {
             testSetup.cfg.Generic.customTags = ["@author ${env:USER}"];
             const res = testSetup.SetLine("void foo();").GetResult();
             // USER env var is different for everybody
-            assert.notEqual("/**\n * @author USER\n */", res);
+            assert.notStrictEqual("/**\n * @author USER\n */", res);
         }
 
         testSetup.cfg.Generic.customTags = ["@author ${env:MY_VARIABLE}"];
         const result = testSetup.SetLine("void foo();").GetResult();
-        assert.equal("/**\n * @author MY_VARIABLE\n */", result);
+        assert.strictEqual("/**\n * @author MY_VARIABLE\n */", result);
     });
 
 });
diff --git a/src/test/CppTests/FileDescription.test.ts b/src/test/CppTests/FileDescription.test.ts
index 19f0790..4772fb7 100644
--- a/src/test/CppTests/FileDescription.test.ts
+++ b/src/test/CppTests/FileDescription.test.ts
@@ -22,19 +22,19 @@ suite("File Description Tests", () => {
     // Tests
     test("#include on next line", () => {
         const result = testSetup.SetLine("#include <iostream>").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @file MockDocument.h\n * @author your name (you@domain.com)\n" +
+        assert.strictEqual("/**\n * @brief \n * \n * @file MockDocument.h\n * @author your name (you@domain.com)\n" +
             " * @date " + date + "\n */", result);
     });
 
     test("#pragma on next line", () => {
         const result = testSetup.SetLine("#pragma Foo").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @file MockDocument.h\n * @author your name (you@domain.com)\n" +
+        assert.strictEqual("/**\n * @brief \n * \n * @file MockDocument.h\n * @author your name (you@domain.com)\n" +
             " * @date " + date + "\n */", result);
     });
 
     test("On first line of document", () => {
         const result = testSetup.SetLine("").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @file MockDocument.h\n * @author your name (you@domain.com)\n" +
+        assert.strictEqual("/**\n * @brief \n * \n * @file MockDocument.h\n * @author your name (you@domain.com)\n" +
             " * @date " + date + "\n */", result);
     });
 
@@ -47,32 +47,32 @@ suite("File Description Tests", () => {
             "   int i;",
             "};",
             ], false).GetResult();
-        assert.equal("/**\n * @brief \n * \n * @file MockDocument.h\n * @author your name (you@domain.com)\n" +
+        assert.strictEqual("/**\n * @brief \n * \n * @file MockDocument.h\n * @author your name (you@domain.com)\n" +
             " * @date " + date + "\n */", result);
     });
 
     test("Don't generate non existing commands", () => {
         testSetup.cfg.File.fileOrder = ["dates"];
         const result = testSetup.SetLine("").GetResult();
-        assert.equal("/**\n */", result);
+        assert.strictEqual("/**\n */", result);
     });
 
     test("version block", () => {
         testSetup.cfg.File.fileOrder = ["version"];
         const result = testSetup.SetLine("").GetResult();
-        assert.equal("/**\n * @version 0.1\n */", result);
+        assert.strictEqual("/**\n * @version 0.1\n */", result);
     });
 
     test("Copyright block", () => {
         testSetup.cfg.File.fileOrder = ["copyright"];
         const result = testSetup.SetLine("").GetResult();
-        assert.equal("/**\n * @copyright Copyright (c) " + year + "\n */", result);
+        assert.strictEqual("/**\n * @copyright Copyright (c) " + year + "\n */", result);
     });
 
     test("version block", () => {
         testSetup.cfg.File.fileOrder = ["version"];
         const result = testSetup.SetLine("").GetResult();
-        assert.equal("/**\n * @version 0.1\n */", result);
+        assert.strictEqual("/**\n * @version 0.1\n */", result);
     });
 
     test("custom block", () => {
@@ -80,7 +80,7 @@ suite("File Description Tests", () => {
         testSetup.cfg.File.customTag = ["First Line", "{year} Year Line", "{date} Date Line",
                                         "{author} Author Line", "{email} Email Line"];
         const result = testSetup.SetLine("").GetResult();
-        assert.equal("/**\n * First Line\n * " + year + " Year Line\n * " + date + " Date Line\n" +
+        assert.strictEqual("/**\n * First Line\n * " + year + " Year Line\n * " + date + " Date Line\n" +
             " * your name Author Line\n * you@domain.com Email Line\n */", result);
     });
 });
diff --git a/src/test/CppTests/FunctionPointer.test.ts b/src/test/CppTests/FunctionPointer.test.ts
index cd318ce..40c924b 100644
--- a/src/test/CppTests/FunctionPointer.test.ts
+++ b/src/test/CppTests/FunctionPointer.test.ts
@@ -18,35 +18,35 @@ suite("C++ - Function pointer Tests", () => {
     // Tests
     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);
+        assert.strictEqual("/**\n * @brief \n * \n * @param a \n * @param b \n * @return int(*)(char*) \n */", result);
     });
 
     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"
+        assert.strictEqual("/**\n * @brief \n * \n * @param a \n * @param b \n"
             + " * @return int(*(*(*)(int))(double))(float) \n */", result);
     });
 
     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);
+        assert.strictEqual("/**\n * @brief \n * \n * @param puts \n * @return int \n */", result);
     });
 
     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();
 
-        assert.equal("/**\n * @brief \n * \n * @param puts \n * @param str "
+        assert.strictEqual("/**\n * @brief \n * \n * @param puts \n * @param str "
             + "\n * @return const struct foo(*)(const char*) \n */", result);
     });
 
     test("Memberpointer in function pointer", () => {
         const result = testSetup.SetLine("void foo(void (SomeClass::* func)());").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @param func \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n * @param func \n */", result);
     });
 
     test("Arraypointer", () => {
         const result = testSetup.SetLine("void some_function(int (*table)[]);").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @param table \n */", result);
+        assert.strictEqual("/**\n * @brief \n * \n * @param table \n */", result);
     });
 });
diff --git a/src/test/CppTests/Operators.test.ts b/src/test/CppTests/Operators.test.ts
index b35cc81..b57d55c 100644
--- a/src/test/CppTests/Operators.test.ts
+++ b/src/test/CppTests/Operators.test.ts
@@ -18,283 +18,283 @@ suite("C++ - Operators Tests", () => {
     // 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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
     });
 
     test("* operator with params", () => {
         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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\n * @brief \n * \n * @param lhs \n * @param rhs \n * @return T \n */", result);
     });
 
     test("& operator with params", () => {
         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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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"
+        assert.strictEqual("/**\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"
+        assert.strictEqual("/**\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"
+        assert.strictEqual("/**\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"
+        assert.strictEqual("/**\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"
+        assert.strictEqual("/**\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"
+        assert.strictEqual("/**\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"
+        assert.strictEqual("/**\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"
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\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);
+        assert.strictEqual("/**\n * @brief \n * \n * @return T \n */", result);
     });
 
     test("() operator", () => {
         let result = testSetup.SetLine("R operator()(const T& a, const T2& b);").GetResult();
-        assert.equal("/**\n * @brief \n * \n * @param a \n * @param b \n * @return R \n */", result);
+        assert.str